diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/Makefile b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/Makefile
new file mode 100644
index 0000000000..f58b8b490b
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/Makefile
@@ -0,0 +1,27 @@
+C=gcc
+CFLAGS=-W -Wall -mavx2
+LDFLAGS=
+EXEC=cnProc_gen
+SRC= $(wildcard *.c)
+OBJ= $(SRC:.c=.o)
+
+all: $(EXEC)
+
+cnProc_gen: $(OBJ)
+	$(CC) -o $@ $^ $(LDFLAGS)
+
+main.o: cnProc_gen.h
+
+%.o: %.c
+	$(CC) -o $@ -c $< $(CFLAGS)
+
+.PHONY: clean mrproper
+
+clean:
+	rm -rf *.o
+
+mrproper: clean
+	rm -rf $(EXEC)
+
+zip: 
+	tar -zcvf sauvegarde.tar.gz main.c cnProc_gen.c cnProc_geno.h Makefile
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/cnProc_gen.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/cnProc_gen.c
new file mode 100644
index 0000000000..31c907d8e9
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/cnProc_gen.c
@@ -0,0 +1,641 @@
+
+#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"
+#include "cnProc_gen.h"
+
+void nrLDPC_cnProc_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z)
+{
+    printf("void nrLDPC_cnProc_BG1_Z%d\n",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;
+
+    //__m256i* p_cnProcBuf;
+    //__m256i* 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;
+
+    //__m256i ymm0, min, sgn;
+    //__m256i* p_cnProcBufResBit;
+
+   // const __m256i* p_ones   = (__m256i*) ones256_epi8;
+  // const __m256i* p_maxLLR = (__m256i*) maxLLR256_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
+
+      // 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}};
+
+    printf("     __m256i ymm0, min, sgn;\n");
+    printf("    const __m256i* p_ones   = (__m256i*) ones256_epi8;\n");
+    printf("    const __m256i* p_maxLLR = (__m256i*) maxLLR256_epi8;\n");
+
+    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 + 31)>>5;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[0]*NR_LDPC_ZMAX)>>5;
+
+
+        // Set pointers to start of group 3
+        //p_cnProcBuf    = (__m256i*) &cnProcBuf   [lut_startAddrCnGroups[0]];
+        //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[0]];
+
+        // Loop over every BN
+                int iprime=0;
+        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++,iprime++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+//                ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+                                printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[0]+lut_idxCnProcG3[j][0] + i);
+//                sgn  = _mm256_sign_epi8(*p_ones, ymm0);
+                printf("                sgn  = _mm256_sign_epi8(*p_ones, ymm0);\n");
+//                min  = _mm256_abs_epi8(ymm0);
+                                printf("                min  = _mm256_abs_epi8(ymm0);\n");
+
+                // 32 CNs of second BN
+//                ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][1] + i];
+                                printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[0]+lut_idxCnProcG3[j][1] + i);
+
+//                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));
+                                printf("                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));\n");
+
+//                sgn  = _mm256_sign_epi8(sgn, ymm0);
+                printf("                sgn  = _mm256_sign_epi8(sgn, ymm0);\n");
+
+                // Store result
+//                min = _mm256_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                printf("                min = _mm256_min_epu8(min, *p_maxLLR);\n");
+//                *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn);
+//                p_cnProcBufResBit++;
+                printf("                ((__m256i*)cnProcB ufRestBit)[%d] = _mm256_sign_epi8(min, sgn);\n",lut_numCnInCnGroups[0]+(j*bitOffsetInGroup)+i);
+            }
+        }
+    }
+
+     // =====================================================================
+    // 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 + 31)>>5;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[1]*NR_LDPC_ZMAX)>>5;
+
+
+        // Set pointers to start of group 4
+        //p_cnProcBuf    = (__m256i*) &cnProcBuf   [lut_startAddrCnGroups[1]];
+        //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[1]];
+
+        // Loop over every BN
+                int iprime=0;
+        for (j=0; j<4; j++)
+        {
+            // Set of results pointer to correct BN address
+            //p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++,iprime++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+//                ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+                                printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[1]+lut_idxCnProcG4[j][0] + i);
+//                sgn  = _mm256_sign_epi8(*p_ones, ymm0);
+                printf("                sgn  = _mm256_sign_epi8(*p_ones, ymm0);\n");
+//                min  = _mm256_abs_epi8(ymm0);
+                                printf("                min  = _mm256_abs_epi8(ymm0);\n");
+
+
+                // Loop over BNs
+                for (k=1; k<3; k++)
+                {
+                    printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[1]+lut_idxCnProcG4[j][k] + i);
+
+    //                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));
+                    printf("                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));\n");
+
+    //                sgn  = _mm256_sign_epi8(sgn, ymm0);
+                    printf("                sgn  = _mm256_sign_epi8(sgn, ymm0);\n");
+                }
+
+                // Store result
+//                min = _mm256_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                printf("                min = _mm256_min_epu8(min, *p_maxLLR);\n");
+//                *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn);
+//                p_cnProcBufResBit++;
+                printf("                ((__m256i*)cnProcBufRestBit)[%d] = _mm256_sign_epi8(min, sgn);\n",lut_numCnInCnGroups[1]+(j*bitOffsetInGroup)+i);
+            }
+        }
+    }
+
+
+    // =====================================================================
+    // 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 + 31)>>5;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[2]*NR_LDPC_ZMAX)>>5;
+
+
+        // Set pointers to start of group 4
+        //p_cnProcBuf    = (__m256i*) &cnProcBuf   [lut_startAddrCnGroups[1]];
+        //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[1]];
+
+        // Loop over every BN
+                int iprime=0;
+        for (j=0; j<5; j++)
+        {
+            // Set of results pointer to correct BN address
+            //p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++,iprime++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+//                ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+                                printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[2]+lut_idxCnProcG5[j][0] + i);
+//                sgn  = _mm256_sign_epi8(*p_ones, ymm0);
+                printf("                sgn  = _mm256_sign_epi8(*p_ones, ymm0);\n");
+//                min  = _mm256_abs_epi8(ymm0);
+                                printf("                min  = _mm256_abs_epi8(ymm0);\n");
+
+
+                // Loop over BNs
+                for (k=1; k<4; k++)
+                {
+                    printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[2]+lut_idxCnProcG5[j][k] + i);
+
+    //                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));
+                    printf("                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));\n");
+
+    //                sgn  = _mm256_sign_epi8(sgn, ymm0);
+                    printf("                sgn  = _mm256_sign_epi8(sgn, ymm0);\n");
+                }
+
+                // Store result
+//                min = _mm256_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                printf("                min = _mm256_min_epu8(min, *p_maxLLR);\n");
+//                *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn);
+//                p_cnProcBufResBit++;
+                printf("                ((__m256i*)cnProcBufRestBit)[%d] = _mm256_sign_epi8(min, sgn);\n",lut_numCnInCnGroups[2]+(j*bitOffsetInGroup)+i);
+            }
+        }
+    }
+
+    // =====================================================================
+    // 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 + 31)>>5;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[3]*NR_LDPC_ZMAX)>>5;
+
+
+        // Set pointers to start of group 4
+        //p_cnProcBuf    = (__m256i*) &cnProcBuf   [lut_startAddrCnGroups[1]];
+        //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[1]];
+
+        // Loop over every BN
+                int iprime=0;
+        for (j=0; j<6; j++)
+        {
+            // Set of results pointer to correct BN address
+            //p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++,iprime++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+//                ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+                                printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[3]+lut_idxCnProcG6[j][0] + i);
+//                sgn  = _mm256_sign_epi8(*p_ones, ymm0);
+                printf("                sgn  = _mm256_sign_epi8(*p_ones, ymm0);\n");
+//                min  = _mm256_abs_epi8(ymm0);
+                                printf("                min  = _mm256_abs_epi8(ymm0);\n");
+
+
+                // Loop over BNs
+                for (k=1; k<5; k++)
+                {
+                    printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[3]+lut_idxCnProcG6[j][k] + i);
+
+    //                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));
+                    printf("                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));\n");
+
+    //                sgn  = _mm256_sign_epi8(sgn, ymm0);
+                    printf("                sgn  = _mm256_sign_epi8(sgn, ymm0);\n");
+                }
+
+                // Store result
+//                min = _mm256_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                printf("                min = _mm256_min_epu8(min, *p_maxLLR);\n");
+//                *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn);
+//                p_cnProcBufResBit++;
+                printf("                ((__m256i*)cnProcBufRestBit)[%d] = _mm256_sign_epi8(min, sgn);\n",lut_numCnInCnGroups[3]+(j*bitOffsetInGroup)+i);
+            }
+        }
+    }
+
+
+    // =====================================================================
+    // 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 + 31)>>5;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[4]*NR_LDPC_ZMAX)>>5;
+
+
+        // Set pointers to start of group 4
+        //p_cnProcBuf    = (__m256i*) &cnProcBuf   [lut_startAddrCnGroups[1]];
+        //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[1]];
+
+        // Loop over every BN
+                int iprime=0;
+        for (j=0; j<7; j++)
+        {
+            // Set of results pointer to correct BN address
+            //p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++,iprime++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+//                ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+                                printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[4]+lut_idxCnProcG7[j][0] + i);
+//                sgn  = _mm256_sign_epi8(*p_ones, ymm0);
+                printf("                sgn  = _mm256_sign_epi8(*p_ones, ymm0);\n");
+//                min  = _mm256_abs_epi8(ymm0);
+                                printf("                min  = _mm256_abs_epi8(ymm0);\n");
+
+
+                // Loop over BNs
+                for (k=1; k<6; k++)
+                {
+                    printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[4]+lut_idxCnProcG7[j][k] + i);
+
+    //                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));
+                    printf("                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));\n");
+
+    //                sgn  = _mm256_sign_epi8(sgn, ymm0);
+                    printf("                sgn  = _mm256_sign_epi8(sgn, ymm0);\n");
+                }
+
+                // Store result
+//                min = _mm256_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                printf("                min = _mm256_min_epu8(min, *p_maxLLR);\n");
+//                *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn);
+//                p_cnProcBufResBit++;
+                printf("                ((__m256i*)cnProcBufRestBit)[%d] = _mm256_sign_epi8(min, sgn);\n",lut_numCnInCnGroups[4]+(j*bitOffsetInGroup)+i);
+            }
+        }
+    }
+
+
+ // =====================================================================
+    // 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 + 31)>>5;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[5]*NR_LDPC_ZMAX)>>5;
+
+
+        // Set pointers to start of group 4
+        //p_cnProcBuf    = (__m256i*) &cnProcBuf   [lut_startAddrCnGroups[1]];
+        //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[1]];
+
+        // Loop over every BN
+                int iprime=0;
+        for (j=0; j<8; j++)
+        {
+            // Set of results pointer to correct BN address
+            //p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++,iprime++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+//                ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+                                printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[5]+lut_idxCnProcG8[j][0] + i);
+//                sgn  = _mm256_sign_epi8(*p_ones, ymm0);
+                printf("                sgn  = _mm256_sign_epi8(*p_ones, ymm0);\n");
+//                min  = _mm256_abs_epi8(ymm0);
+                                printf("                min  = _mm256_abs_epi8(ymm0);\n");
+
+
+                // Loop over BNs
+                for (k=1; k<7; k++)
+                {
+                    printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[5]+lut_idxCnProcG8[j][k] + i);
+
+    //                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));
+                    printf("                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));\n");
+
+    //                sgn  = _mm256_sign_epi8(sgn, ymm0);
+                    printf("                sgn  = _mm256_sign_epi8(sgn, ymm0);\n");
+                }
+
+                // Store result
+//                min = _mm256_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                printf("                min = _mm256_min_epu8(min, *p_maxLLR);\n");
+//                *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn);
+//                p_cnProcBufResBit++;
+                printf("                ((__m256i*)cnProcBufRestBit)[%d] = _mm256_sign_epi8(min, sgn);\n",lut_numCnInCnGroups[5]+(j*bitOffsetInGroup)+i);
+            }
+        }
+    }
+
+// =====================================================================
+    // 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 + 31)>>5;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[6]*NR_LDPC_ZMAX)>>5;
+
+
+        // Set pointers to start of group 9
+        //p_cnProcBuf    = (__m256i*) &cnProcBuf   [lut_startAddrCnGroups[1]];
+        //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[1]];
+
+        // Loop over every BN
+                int iprime=0;
+        for (j=0; j<9; j++)
+        {
+            // Set of results pointer to correct BN address
+            //p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++,iprime++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+//                ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+                                printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[6]+lut_idxCnProcG9[j][0] + i);
+//                sgn  = _mm256_sign_epi8(*p_ones, ymm0);
+                printf("                sgn  = _mm256_sign_epi8(*p_ones, ymm0);\n");
+//                min  = _mm256_abs_epi8(ymm0);
+                                printf("                min  = _mm256_abs_epi8(ymm0);\n");
+
+
+                // Loop over BNs
+                for (k=1; k<8; k++)
+                {
+                    printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[6]+lut_idxCnProcG9[j][k] + i);
+
+    //                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));
+                    printf("                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));\n");
+
+    //                sgn  = _mm256_sign_epi8(sgn, ymm0);
+                    printf("                sgn  = _mm256_sign_epi8(sgn, ymm0);\n");
+                }
+
+                // Store result
+//                min = _mm256_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                printf("                min = _mm256_min_epu8(min, *p_maxLLR);\n");
+//                *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn);
+//                p_cnProcBufResBit++;
+                printf("                ((__m256i*)cnProcBufRestBit)[%d] = _mm256_sign_epi8(min, sgn);\n",lut_numCnInCnGroups[6]+(j*bitOffsetInGroup)+i);
+            }
+        }
+    }
+
+    // =====================================================================
+    // 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 + 31)>>5;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[7]*NR_LDPC_ZMAX)>>5;
+
+
+        // Set pointers to start of group 10
+        //p_cnProcBuf    = (__m256i*) &cnProcBuf   [lut_startAddrCnGroups[1]];
+        //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[1]];
+
+        // Loop over every BN
+                int iprime=0;
+        for (j=0; j<10; j++)
+        {
+            // Set of results pointer to correct BN address
+            //p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++,iprime++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+//                ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+                                printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[7]+lut_idxCnProcG10[j][0] + i);
+//                sgn  = _mm256_sign_epi8(*p_ones, ymm0);
+                printf("                sgn  = _mm256_sign_epi8(*p_ones, ymm0);\n");
+//                min  = _mm256_abs_epi8(ymm0);
+                                printf("                min  = _mm256_abs_epi8(ymm0);\n");
+
+
+                // Loop over BNs
+                for (k=1; k<9; k++)
+                {
+                    printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[7]+lut_idxCnProcG10[j][k] + i);
+
+    //                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));
+                    printf("                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));\n");
+
+    //                sgn  = _mm256_sign_epi8(sgn, ymm0);
+                    printf("                sgn  = _mm256_sign_epi8(sgn, ymm0);\n");
+                }
+
+                // Store result
+//                min = _mm256_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                printf("                min = _mm256_min_epu8(min, *p_maxLLR);\n");
+//                *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn);
+//                p_cnProcBufResBit++;
+                printf("                ((__m256i*)cnProcBufRestBit)[%d] = _mm256_sign_epi8(min, sgn);\n",lut_numCnInCnGroups[7]+(j*bitOffsetInGroup)+i);
+            }
+        }
+    }
+
+
+ // =====================================================================
+    // 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 + 31)>>5;
+
+        // Set the offset to each bit within a group in terms of 32 Byte
+        bitOffsetInGroup = (lut_numCnInCnGroups_BG1_R13[8]*NR_LDPC_ZMAX)>>5;
+
+
+        // Set pointers to start of group 19
+        //p_cnProcBuf    = (__m256i*) &cnProcBuf   [lut_startAddrCnGroups[1]];
+        //p_cnProcBufRes = (__m256i*) &cnProcBufRes[lut_startAddrCnGroups[1]];
+
+        // Loop over every BN
+                int iprime=0;
+        for (j=0; j<19; j++)
+        {
+            // Set of results pointer to correct BN address
+            //p_cnProcBufResBit = p_cnProcBufRes + (j*bitOffsetInGroup);
+
+            // Loop over CNs
+            for (i=0; i<M; i++,iprime++)
+            {
+                // Abs and sign of 32 CNs (first BN)
+//                ymm0 = p_cnProcBuf[lut_idxCnProcG3[j][0] + i];
+                                printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[8]+lut_idxCnProcG19[j][0] + i);
+//                sgn  = _mm256_sign_epi8(*p_ones, ymm0);
+                printf("                sgn  = _mm256_sign_epi8(*p_ones, ymm0);\n");
+//                min  = _mm256_abs_epi8(ymm0);
+                                printf("                min  = _mm256_abs_epi8(ymm0);\n");
+
+
+                // Loop over BNs
+                for (k=1; k<18; k++)
+                {
+                    printf("                ymm0 = ((__m256i*)&cnProcBuf)[%d];\n",lut_startAddrCnGroups[8]+lut_idxCnProcG19[j][k] + i);
+
+    //                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));
+                    printf("                min  = _mm256_min_epu8(min, _mm256_abs_epi8(ymm0));\n");
+
+    //                sgn  = _mm256_sign_epi8(sgn, ymm0);
+                    printf("                sgn  = _mm256_sign_epi8(sgn, ymm0);\n");
+                }
+
+                // Store result
+//                min = _mm256_min_epu8(min, *p_maxLLR); // 128 in epi8 is -127
+                printf("                min = _mm256_min_epu8(min, *p_maxLLR);\n");
+//                *p_cnProcBufResBit = _mm256_sign_epi8(min, sgn);
+//                p_cnProcBufResBit++;
+                printf("                ((__m256i*)cnProcBufRestBit)[%d] = _mm256_sign_epi8(min, sgn);\n",lut_numCnInCnGroups[8]+(j*bitOffsetInGroup)+i);
+            }
+        }
+    }
+
+}//end of the function  nrLDPC_cnProc_BG1
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/cnProc_gen.h b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/cnProc_gen.h
new file mode 100644
index 0000000000..1868fe1163
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/cnProc_gen.h
@@ -0,0 +1,7 @@
+#ifndef NRLDPC_CN_GEN
+#define NRLDPC_DN_GEN
+
+void nrLDPC_cnProc_BG1(t_nrLDPC_lut* p_lut, t_nrLDPC_procBuf* p_procBuf, uint16_t Z);
+
+
+#endif
diff --git a/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/main.c b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/main.c
new file mode 100644
index 0000000000..45b79ffa52
--- /dev/null
+++ b/openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_tools/main.c
@@ -0,0 +1,81 @@
+#include <stdio.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"
+#include "cnProc_gen.h"
+
+int main(int argc, char *argv[])
+{
+  //short lift_size[51]= {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};
+//  unsigned int errors, errors_bit, crc_misses;
+ // double errors_bit_uncoded;
+  //short block_length=8448; // decoder supports length: 1201 -> 1280, 2401 -> 2560
+
+ // short No_iteration=5;
+  //int n_segments=1;
+  //double rate=0.333;
+  //int nom_rate=1;
+  //int denom_rate=3;
+  //double SNR0=-2.0,SNR,SNR_lin;
+  //unsigned char qbits=8;
+ // unsigned int decoded_errors[10000]; // initiate the size of matrix equivalent to size of SNR
+  //int c,i=0, i1 = 0;
+
+ // int n_trials = 1;
+ // double SNR_step = 0.1;
+
+//  randominit(0);
+  //int test_uncoded= 0;
+
+  //short BG=1,Zc,Kb;
+
+
+//  cpu_freq_GHz = get_cpu_freq_GHz();
+  //printf("the decoder supports BG2, Kb=10, Z=128 & 256\n");
+  //printf(" range of blocklength: 1201 -> 1280, 2401 -> 2560\n");
+ // printf("block length %d: \n", block_length);
+  //printf("n_trials %d: \n", n_trials);
+ // printf("SNR0 %f: \n", SNR0);
+
+  //find minimum value in all sets of lifting size
+ /* Zc=0;
+
+  for (i1=0; i1 < 51; i1++)
+  {
+    if (lift_size[i1] >= (double) block_length/Kb)
+    {
+      Zc = lift_size[i1];
+      //printf("%d\n",Zc);
+      break;
+    }
+  }*/
+  // Allocate LDPC decoder buffers
+ // p_nrLDPC_procBuf = nrLDPC_init_mem();
+  t_nrLDPC_procBuf cnProcBuf;
+  t_nrLDPC_procBuf* p_procBuf = &cnProcBuf;
+
+//  load_nrLDPClib();
+    t_nrLDPC_lut lut_numCnInCnGroups;
+    t_nrLDPC_lut* p_lut = &lut_numCnInCnGroups;
+
+//  load_nrLDPClib_ref("_orig", &encoder_orig);
+
+    nrLDPC_cnProc_BG1(p_lut,p_procBuf,384);
+	//nrLDPC_cnProc_BG1(&lut_numCnInCnGroups, &cnProcBuf, 380);
+  //for (block_length=8;block_length<=MAX_BLOCK_LENGTH;block_length+=8)
+
+  //determine number of bits in codeword
+/*
+  char fname[200];
+  sprintf(fname,"cnProc_BG1_Zc_%d.c",384);
+  FILE *fd=fopen(fname,"w");
+//  AssertFatal(fd!=NULL,"cannot open %s\n",fname);
+*/
+  //fclose(fd);
+
+  return(0);
+}