diff --git a/cmake_targets/CMakeLists.txt b/cmake_targets/CMakeLists.txt
index c4e2399351..668c3acc2e 100644
--- a/cmake_targets/CMakeLists.txt
+++ b/cmake_targets/CMakeLists.txt
@@ -1143,15 +1143,19 @@ set(PHY_POLARSRC
   ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_procedures.c
   ${OPENAIR1_DIR}/PHY/CODING/nrPolar_tools/nr_polar_sequence_pattern.c
 )
+set(PHY_SMALLBLOCKSRC
+  ${OPENAIR1_DIR}/PHY/CODING/nrSmallBlock/encodeSmallBlock.c
+  ${OPENAIR1_DIR}/PHY/CODING/nrSmallBlock/decodeSmallBlock.c
+)
 set(PHY_TURBOIF
   ${OPENAIR1_DIR}/PHY/CODING/coding_load.c
-  )
+)
 set(PHY_LDPCSRC
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder.c
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder2.c
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_generate_coefficient.c
-  )
+)
 
 add_library(coding MODULE ${PHY_TURBOSRC} )
 
@@ -1326,6 +1330,7 @@ set(PHY_SRC_UE
   ${OPENAIR1_DIR}/PHY/TOOLS/time_meas.c
   ${OPENAIR1_DIR}/PHY/TOOLS/lut.c
   ${PHY_POLARSRC}
+  ${PHY_SMALLBLOCKSRC}
   ${PHY_LDPCSRC}
   )
 
@@ -1372,6 +1377,7 @@ set(PHY_SRC_UE
   ${OPENAIR1_DIR}/PHY/INIT/nr_init_ue.c
   #  ${OPENAIR1_DIR}/SIMULATION/NR_UE_PHY/unit_tests/src/pucch_uci_test.c
   ${PHY_POLARSRC}
+  ${PHY_SMALLBLOCKSRC}
   ${PHY_LDPCSRC}
   )
 
@@ -2558,6 +2564,9 @@ target_link_libraries (dlsim_tm4
 add_executable(polartest ${OPENAIR1_DIR}/PHY/CODING/TESTBENCH/polartest.c)
 target_link_libraries(polartest SIMU PHY PHY_NR PHY_COMMON m ${ATLAS_LIBRARIES})
 
+add_executable(smallblocktest ${OPENAIR1_DIR}/PHY/CODING/TESTBENCH/smallblocktest.c)
+target_link_libraries(smallblocktest SIMU PHY PHY_NR PHY_COMMON m ${ATLAS_LIBRARIES})
+
 add_executable(ldpctest  ${OPENAIR1_DIR}/PHY/CODING/TESTBENCH/ldpctest.c)
 target_link_libraries(ldpctest SIMU PHY PHY_NR m ${ATLAS_LIBRARIES})
 
diff --git a/openair1/PHY/CODING/TESTBENCH/ldpctest.c b/openair1/PHY/CODING/TESTBENCH/ldpctest.c
index 6db9548dbe..d8ba986175 100644
--- a/openair1/PHY/CODING/TESTBENCH/ldpctest.c
+++ b/openair1/PHY/CODING/TESTBENCH/ldpctest.c
@@ -382,12 +382,12 @@ int test_ldpc(short No_iteration,
 
         //Uncoded BER
         if (channel_output_fixed[j][i]<0)
-            channel_output_uncoded[j][i]=1;  //QPSK demod
-	else
-            channel_output_uncoded[j][i]=0;
+        	channel_output_uncoded[j][i]=1;  //QPSK demod
+        else
+        	channel_output_uncoded[j][i]=0;
 
         if (channel_output_uncoded[j][i] != channel_input[j][i-2*Zc])
-	  *errors_bit_uncoded = (*errors_bit_uncoded) + 1;
+        	*errors_bit_uncoded = (*errors_bit_uncoded) + 1;
 
 	}
       } // End segments
diff --git a/openair1/PHY/CODING/TESTBENCH/polartest.c b/openair1/PHY/CODING/TESTBENCH/polartest.c
index e4b4758493..72ef16907c 100644
--- a/openair1/PHY/CODING/TESTBENCH/polartest.c
+++ b/openair1/PHY/CODING/TESTBENCH/polartest.c
@@ -62,7 +62,6 @@ int main(int argc, char *argv[]) {
 	int16_t nBitError = 0; // -1 = Decoding failed (All list entries have failed the CRC checks).
 	uint32_t decoderState=0, blockErrorState=0; //0 = Success, -1 = Decoding failed, 1 = Block Error.
 	uint16_t testLength = 0, coderLength = 0, blockErrorCumulative=0, bitErrorCumulative=0;
-	double timeEncoderCumulative = 0, timeDecoderCumulative = 0;
 	uint8_t aggregation_level = 8, decoderListSize = 8, pathMetricAppr = 0, matlabDebug = 0;
 
 	while ((arguments = getopt (argc, argv, "s:d:f:c:i:l:a:hqgm")) != -1)
@@ -217,7 +216,7 @@ int main(int argc, char *argv[]) {
 	memset(dci_estimation,0,sizeof(uint32_t)*4);
 	printf("dci_estimation: [0]->0x%08x \t [1]->0x%08x \t [2]->0x%08x \t [3]->0x%08x\n",
 			dci_estimation[0], dci_estimation[1], dci_estimation[2], dci_estimation[3]);
-	nr_bit2byte_uint32_8_t(encoder_output, currentPtrDCI->encoderLength, encoder_outputByte);
+	nr_bit2byte_uint32_8(encoder_output, currentPtrDCI->encoderLength, encoder_outputByte);
 	printf("[polartest] encoder_outputByte: ");
 	for (int i = 0; i < currentPtrDCI->encoderLength; i++) printf("%d-", encoder_outputByte[i]);
 	printf("\n");
@@ -257,7 +256,7 @@ int main(int argc, char *argv[]) {
 	uint32_t testInputcrc2=0x00291880;
 
 	uint8_t testInputCRC2[8];
-	nr_crc_bit2bit_uint32_8_t(testInputCRC, 32, testInputCRC2);
+	nr_crc_bit2bit_uint32_8(testInputCRC, 32, testInputCRC2);
 	printf("testInputCRC2: [0]->%x \t [1]->%x \t [2]->%x \t [3]->%x\n"
 		   "            [4]->%x \t [5]->%x \t [6]->%x \t [7]->%x\n",
 				testInputCRC2[0], testInputCRC2[1], testInputCRC2[2], testInputCRC2[3],
@@ -339,7 +338,7 @@ int main(int argc, char *argv[]) {
 	for (int i=0; i<currentPtr->payloadBits; i++) aPrioriArray[i] = NAN;
 
 	for (SNR = SNRstart; SNR <= SNRstop; SNR += SNRinc) {
-	  printf("SNR %f\n",SNR);
+		printf("SNR %f\n",SNR);
 		SNR_lin = pow(10, SNR/10);
 		for (itr = 1; itr <= iterations; itr++) {
 
@@ -420,11 +419,11 @@ int main(int argc, char *argv[]) {
 			uint8_t nr_pbch_interleaver[NR_POLAR_PBCH_PAYLOAD_BITS];
 			memset((void*)nr_pbch_interleaver,0, NR_POLAR_PBCH_PAYLOAD_BITS);
 			nr_init_pbch_interleaver(nr_pbch_interleaver);
-			for (int i=0; i<=31;i++)
+			/*for (int i=0; i<=31;i++)
 				printf("nr_pbch_interleaver[%d]=%d\n",i,nr_pbch_interleaver[i]);
 
 			  for (int i=0; i<NR_POLAR_PBCH_PAYLOAD_BITS; i++)
-				  printf("nr_pbch_interleaver_operation[%d]=%d\n",i,(*(nr_pbch_interleaver+i)));
+				  printf("nr_pbch_interleaver_operation[%d]=%d\n",i,(*(nr_pbch_interleaver+i)));*/
 
 
 			start_meas(&timeEncoder);
@@ -438,25 +437,28 @@ int main(int argc, char *argv[]) {
 			printf("encoderOutput: [1]->0x%08x\n", encoderOutput[1]);*/
 
 			//Bit-to-byte:
-			nr_bit2byte_uint32_8_t(encoderOutput, coderLength, encoderOutputByte);
+			nr_bit2byte_uint32_8(encoderOutput, coderLength, encoderOutputByte);
 
 			//BPSK modulation
 			for(int i=0; i<coderLength; i++) {
 				if (encoderOutputByte[i] == 0)
-					modulatedInput[i]=1/sqrt(2);
+					modulatedInput[i]=1;
+				    //modulatedInput[i]=1/sqrt(2);
 				else
-					modulatedInput[i]=(-1)/sqrt(2);
+					modulatedInput[i]=(-1);
+					//modulatedInput[i]=((-1)/sqrt(2));
 
-				channelOutput[i] = modulatedInput[i] + (gaussdouble(0.0,1.0) * (1/sqrt(2*SNR_lin)));
+				channelOutput[i] = modulatedInput[i] + (gaussdouble(0.0,1.0) * (1/sqrt(SNR_lin)));
+				//channelOutput[i] = modulatedInput[i] + (gaussdouble(0.0,1.0) * (1/sqrt(2*SNR_lin)));
 
-				
 				if (decoder_int16==1) {
-				  if (channelOutput[i] > 15) channelOutput_int16[i] = 127;
-				  else if (channelOutput[i] < -16) channelOutput_int16[i] = -128;
-				  else channelOutput_int16[i] = (int16_t) (8*channelOutput[i]);
+					if (channelOutput[i] > 15)
+						channelOutput_int16[i] = 127;
+					else if (channelOutput[i] < -16)
+						channelOutput_int16[i] = -128;
+					else
+						channelOutput_int16[i] = (int16_t) (8*channelOutput[i]);
 				}
-
-
 			}
 
 			start_meas(&timeDecoder);
@@ -466,44 +468,38 @@ int main(int argc, char *argv[]) {
 									 	 NR_POLAR_DECODER_LISTSIZE,
 									 	 aPrioriArray,
 									 	 NR_POLAR_DECODER_PATH_METRIC_APPROXIMATION);*/
-			if (decoder_int16==0)
-			  decoderState = polar_decoder_aPriori(channelOutput,
-							       estimatedOutput,
-							       currentPtr,
-							       NR_POLAR_DECODER_LISTSIZE,
-							       NR_POLAR_DECODER_PATH_METRIC_APPROXIMATION,
-							       aPrioriArray);
-			else 
-			  decoderState = polar_decoder_int16(channelOutput_int16,
-							     (uint64_t*)estimatedOutput,
-							     currentPtr);
-
+			if (decoder_int16 == 1)
+				decoderState = polar_decoder_int16(channelOutput_int16,
+												   (uint64_t*) estimatedOutput,
+												   currentPtr);
+			else
+				decoderState = polar_decoder_aPriori(channelOutput,
+													 estimatedOutput, currentPtr,
+													 NR_POLAR_DECODER_LISTSIZE,
+													 NR_POLAR_DECODER_PATH_METRIC_APPROXIMATION,
+													 aPrioriArray);
 			  
 			stop_meas(&timeDecoder);
 			/*printf("testInput: [0]->0x%08x\n", testInput[0]);
 			printf("estimatedOutput: [0]->0x%08x\n", estimatedOutput[0]);*/
 
-
 			//calculate errors
 			if (decoderState!=0) {
 				blockErrorState=-1;
 				nBitError=-1;
 			} else {
-			  for (int j = 0; j < currentPtr->payloadBits; j++) {
-			    if (((estimatedOutput[0]>>j) & 1) != ((testInput[0]>>j) & 1)) nBitError++;
+				for (int j = 0; j < currentPtr->payloadBits; j++) {
+					if (((estimatedOutput[0]>>j) & 1) != ((testInput[0]>>j) & 1))
+						nBitError++;
 			    //			    printf("bit %d: %d => %d\n",j,(testInput[0]>>j)&1,(estimatedOutput[0]>>j)&1);
-			  }
-			
-
-			  if (nBitError>0) { 
-			    blockErrorState=1; 
-			    //			    printf("Error: Input %x, Output %x\n",testInput[0],estimatedOutput[0]);
-			  }
+					}
+				if (nBitError>0) {
+					blockErrorState=1;
+			        //printf("Error: Input %x, Output %x\n",testInput[0],estimatedOutput[0]);
+					}
 			}
 
 			//Iteration times are in microseconds.
-			timeEncoderCumulative+=(timeEncoder.diff/(cpu_freq_GHz*1000.0));
-			timeDecoderCumulative+=(timeDecoder.diff/(cpu_freq_GHz*1000.0));
 			fprintf(logFile,",%f,%d,%d,%f,%f\n", SNR, nBitError, blockErrorState,
 					(timeEncoder.diff/(cpu_freq_GHz*1000.0)), (timeDecoder.diff/(cpu_freq_GHz*1000.0)));
 
@@ -521,17 +517,16 @@ int main(int argc, char *argv[]) {
 
 		}
 		//Calculate error statistics for the SNR.
-		printf("[ListSize=%d, Appr=%d] SNR=%+8.3f, BLER=%9.6f, BER=%12.9f, t_Encoder=%9.3fus, t_Decoder=%9.3fus\n",
+		printf("[ListSize=%d, Appr=%d] SNR=%+8.3f, BLER=%9.6f, BER=%12.9f, t_Encoder=%12.6fus, t_Decoder=%12.6fus\n",
 				decoderListSize, pathMetricAppr, SNR, ((double)blockErrorCumulative/iterations),
 				((double)bitErrorCumulative / (iterations*testLength)),
-		       (double)timeEncoder.diff/timeEncoder.trials/(cpu_freq_GHz*1000.0),(double)timeDecoder.diff/timeDecoder.trials/(cpu_freq_GHz*1000.0));
-		       //(timeEncoderCumulative/iterations),timeDecoderCumulative/iterations);
+				(double)timeEncoder.diff/timeEncoder.trials/(cpu_freq_GHz*1000.0),
+				(double)timeDecoder.diff/timeDecoder.trials/(cpu_freq_GHz*1000.0));
 
 		if (blockErrorCumulative==0 && bitErrorCumulative==0)
 		  break;
 
 		blockErrorCumulative = 0; bitErrorCumulative = 0;
-		timeEncoderCumulative = 0; timeDecoderCumulative = 0;
 	}
 
 	print_meas(&timeEncoder,"polar_encoder",NULL,NULL);
diff --git a/openair1/PHY/CODING/TESTBENCH/smallblocktest.c b/openair1/PHY/CODING/TESTBENCH/smallblocktest.c
new file mode 100644
index 0000000000..7ffa3900a6
--- /dev/null
+++ b/openair1/PHY/CODING/TESTBENCH/smallblocktest.c
@@ -0,0 +1,169 @@
+#include "PHY/CODING/nrSmallBlock/nr_small_block_defs.h"
+#include "SIMULATION/TOOLS/sim.h"
+#include <getopt.h>
+
+//#define DEBUG_SMALLBLOCKTEST
+
+signed char quantize(double D, double x, unsigned char B)
+{
+	double qxd;
+	short maxlev;
+	qxd = floor(x/D);
+
+	maxlev = 1<<(B-1);//(char)(pow(2,B-1));
+
+	if (qxd <= -maxlev)
+		qxd = -maxlev;
+	else if (qxd >= maxlev)
+		qxd = maxlev-1;
+
+	return((char)qxd);
+}
+
+int main(int argc, char *argv[]) {
+
+	time_stats_t timeEncoder,timeDecoder;
+	opp_enabled=1;
+	cpu_freq_GHz = get_cpu_freq_GHz();
+	reset_meas(&timeEncoder);
+	reset_meas(&timeDecoder);
+	randominit(0);
+
+	int arguments, iterations = 1000, matlabDebug = 0, messageLength = 11;
+	uint32_t testInput, encoderOutput, codingDifference, nBitError=0, blockErrorState = 0, blockErrorCumulative=0, bitErrorCumulative=0;
+	uint16_t estimatedOutput;
+	double SNRstart = -20.0, SNRstop = 5.0, SNRinc= 0.5; //dB
+	double SNR, SNR_lin, sigma;
+	double modulatedInput[NR_SMALL_BLOCK_CODED_BITS], channelOutput[NR_SMALL_BLOCK_CODED_BITS];
+	int16_t channelOutput_int16[NR_SMALL_BLOCK_CODED_BITS];
+	int8_t channelOutput_int8[NR_SMALL_BLOCK_CODED_BITS];
+	unsigned char qbits=8;
+
+	while ((arguments = getopt (argc, argv, "s:d:f:l:i:mhg")) != -1)
+	switch (arguments)
+	{
+		case 's':
+			SNRstart = atof(optarg);
+			break;
+
+		case 'd':
+			SNRinc = atof(optarg);
+			break;
+
+		case 'f':
+			SNRstop = atof(optarg);
+			break;
+
+		case 'l':
+			messageLength = atoi(optarg);
+			break;
+
+		case 'i':
+			iterations = atoi(optarg);
+			break;
+
+		case 'm':
+			matlabDebug = 1;
+			//#define DEBUG_POLAR_MATLAB
+			break;
+
+		case 'g':
+			iterations = 1;
+			SNRstart = -6.0;
+			SNRstop = -6.0;
+			messageLength = 11;
+			break;
+
+		case 'h':
+			printf("./smallblocktest -s SNRstart -d SNRinc -f SNRstop -l messageLength -i iterations -m Matlab Debug\n");
+			exit(-1);
+
+		default:
+			perror("[smallblocktest.c] Problem at argument parsing with getopt");
+			exit(-1);
+	}
+
+
+	uint16_t mask = 0x07ff >> (11-messageLength);
+	for (SNR = SNRstart; SNR <= SNRstop; SNR += SNRinc) {
+		printf("SNR %f\n",SNR);
+		SNR_lin = pow(10, SNR/10.0);
+		sigma = 1.0/sqrt(SNR_lin);
+
+		for (int itr = 1; itr <= iterations; itr++) {
+
+			//Generate random test input of length "messageLength"
+			testInput = 0;
+			for (int i = 1; i < messageLength; i++) {
+				testInput |= ( ((uint32_t) (rand()%2)) &1);
+				testInput<<=1;
+				}
+			testInput |= ( ((uint32_t) (rand()%2)) &1);
+
+			//Encoding
+			start_meas(&timeEncoder);
+			encoderOutput = encodeSmallBlock((uint16_t*)&testInput, (uint8_t)messageLength);
+			stop_meas(&timeEncoder);
+
+			for (int i=0; i<NR_SMALL_BLOCK_CODED_BITS; i++) {
+				//BPSK modulation
+				if ((encoderOutput>>i) & 1 ) {
+					modulatedInput[i]=-1;
+				} else {
+					modulatedInput[i]=1;
+				}
+
+				//AWGN
+				channelOutput[i] = modulatedInput[i] + ( gaussdouble(0.0,1.0) * ( 1/sqrt(SNR_lin) ) );
+
+				//Quantization
+				channelOutput_int8[i] = quantize(sigma/16.0, channelOutput[i], qbits);
+			}
+
+			//Decoding
+			start_meas(&timeDecoder);
+			estimatedOutput = decodeSmallBlock(channelOutput_int8, (uint8_t)messageLength);
+			stop_meas(&timeDecoder);
+
+#ifdef DEBUG_SMALLBLOCKTEST
+			printf("[smallblocktest] Input = 0x%x, Output = 0x%x, DecoderOutput = 0x%x\n", testInput, encoderOutput, estimatedOutput);
+			for (int i=0;i<32;i++)
+				printf("[smallblocktest] Input[%d] = %d, Output[%d] = %d, Mask[%d] = %d\n", i, (testInput>>i)&1, i, (estimatedOutput>>i)&1, i, (mask>>i)&1);
+#endif
+
+			//Error Calculation
+			estimatedOutput &= mask;
+			codingDifference = ((uint32_t)estimatedOutput) ^ testInput; // Count the # of 1's in codingDifference by Brian Kernighan’s algorithm.
+
+			//for (int i=0;i<32;i++)
+				//printf("[smallblocktest] Input[%d] = %d, Output[%d] = %d, codingDifference[%d]=%d, Mask[%d] = %d, bitError = %d\n", i, (testInput>>i)&1, i, (estimatedOutput>>i)&1, i, (codingDifference>>i)&1, i, (mask>>i)&1, nBitError);
+
+
+			for (nBitError = 0; codingDifference; nBitError++)
+				codingDifference &= codingDifference - 1;
+
+			blockErrorState = (nBitError > 0) ? 1 : 0;
+
+			blockErrorCumulative+=blockErrorState;
+			bitErrorCumulative+=nBitError;
+
+			nBitError = 0; blockErrorState = 0;
+		}
+
+		//Error statistics for the SNR; iteration times are in nanoseconds and microseconds, respectively.
+		printf("[smallblocktest] SNR=%+7.3f, BER=%9.6f, BLER=%9.6f, t_Encoder=%9.3fns, t_Decoder=%7.3fus\n",
+				SNR,
+				((double)bitErrorCumulative / (iterations*messageLength)),
+				((double)blockErrorCumulative/iterations),
+				((double)timeEncoder.diff/timeEncoder.trials)/(cpu_freq_GHz),
+				((double)timeDecoder.diff/timeDecoder.trials)/(cpu_freq_GHz*1000.0));
+
+		blockErrorCumulative=0;
+		bitErrorCumulative=0;
+	}
+
+	print_meas(&timeEncoder, "smallblock_encoder", NULL, NULL);
+	print_meas(&timeDecoder, "smallblock_decoder", NULL, NULL);
+
+	return (0);
+}
diff --git a/openair1/PHY/CODING/nrPolar_tools/nr_bitwise_operations.c b/openair1/PHY/CODING/nrPolar_tools/nr_bitwise_operations.c
index beabeead36..a5e78b6f2b 100644
--- a/openair1/PHY/CODING/nrPolar_tools/nr_bitwise_operations.c
+++ b/openair1/PHY/CODING/nrPolar_tools/nr_bitwise_operations.c
@@ -21,7 +21,7 @@
 
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 
-void nr_bit2byte_uint32_8_t(uint32_t *in, uint16_t arraySize, uint8_t *out) {
+void nr_bit2byte_uint32_8(uint32_t *in, uint16_t arraySize, uint8_t *out) {
 	uint8_t arrayInd = ceil(arraySize / 32.0);
 	for (int i = 0; i < (arrayInd-1); i++) {
 		for (int j = 0; j < 32; j++) {
@@ -32,7 +32,7 @@ void nr_bit2byte_uint32_8_t(uint32_t *in, uint16_t arraySize, uint8_t *out) {
 	for (int j = 0; j < arraySize - ((arrayInd-1) * 32); j++) out[j + ((arrayInd-1) * 32)] = (in[(arrayInd-1)] >> j) & 1;
 }
 
-void nr_byte2bit_uint8_32_t(uint8_t *in, uint16_t arraySize, uint32_t *out) {
+void nr_byte2bit_uint8_32(uint8_t *in, uint16_t arraySize, uint32_t *out) {
 	uint8_t arrayInd = ceil(arraySize / 32.0);
 	for (int i = 0; i < arrayInd; i++) {
 		out[i]=0;
@@ -44,7 +44,7 @@ void nr_byte2bit_uint8_32_t(uint8_t *in, uint16_t arraySize, uint32_t *out) {
 	}
 }
 
-void nr_crc_bit2bit_uint32_8_t(uint32_t *in, uint16_t arraySize, uint8_t *out) {
+void nr_crc_bit2bit_uint32_8(uint32_t *in, uint16_t arraySize, uint8_t *out) {
 	out[0]=0xff;
 	out[1]=0xff;
 	out[2]=0xff;
diff --git a/openair1/PHY/CODING/nrPolar_tools/nr_polar_decoder.c b/openair1/PHY/CODING/nrPolar_tools/nr_polar_decoder.c
index 305a9c6266..b754bda1f9 100644
--- a/openair1/PHY/CODING/nrPolar_tools/nr_polar_decoder.c
+++ b/openair1/PHY/CODING/nrPolar_tools/nr_polar_decoder.c
@@ -39,12 +39,11 @@
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 #include "assertions.h"
 
-int8_t polar_decoder(
-		double *input,
-		uint8_t *out,
-		t_nrPolar_paramsPtr polarParams,
-		uint8_t listSize,
-		uint8_t pathMetricAppr)
+int8_t polar_decoder(double *input,
+					 uint8_t *out,
+					 t_nrPolar_paramsPtr polarParams,
+					 uint8_t listSize,
+					 uint8_t pathMetricAppr)
 {
 	//Assumes no a priori knowledge.
 
@@ -276,18 +275,18 @@ int8_t polar_decoder(
 	/*
 	 * Return bits.
 	 */
-	//nr_byte2bit_uint8_32_t(polarParams->nr_polar_A, polarParams->payloadBits, out);
+	//nr_byte2bit_uint8_32(polarParams->nr_polar_A, polarParams->payloadBits, out);
 	return(0);
 }
 
 int8_t polar_decoder_aPriori(double *input,
-			     uint32_t *out,
-			     t_nrPolar_paramsPtr polarParams,
-			     uint8_t listSize,
-			     uint8_t pathMetricAppr,
-			     double *aPrioriPayload)
+							 uint32_t *out,
+							 t_nrPolar_paramsPtr polarParams,
+							 uint8_t listSize,
+							 uint8_t pathMetricAppr,
+							 double *aPrioriPayload)
 {
-  uint8_t ***bit = nr_alloc_uint8_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
+    uint8_t ***bit = nr_alloc_uint8_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
 	uint8_t **bitUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
 	uint8_t **llrUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
 	double ***llr = nr_alloc_double_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
@@ -528,269 +527,10 @@ int8_t polar_decoder_aPriori(double *input,
 	/*
 	 * Return bits.
 	 */
-	nr_byte2bit_uint8_32_t(polarParams->nr_polar_A, polarParams->payloadBits, out);
-
-	return(0);
-
-}
-
-
-
-int8_t polar_decoder_aPriori_timing(double *input,
-									uint32_t *out,
-									t_nrPolar_paramsPtr polarParams,
-									uint8_t listSize,
-									uint8_t pathMetricAppr,
-									double *aPrioriPayload,
-									double cpuFreqGHz,
-									FILE* logFile)
-{
-
-	uint8_t ***bit = nr_alloc_uint8_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-	uint8_t **bitUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
-	uint8_t **llrUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
-	double ***llr = nr_alloc_double_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
-	uint8_t **crcChecksum = nr_alloc_uint8_2D_array(polarParams->crcParityBits, 2*listSize);
-	double *pathMetric = malloc(sizeof(double)*(2*listSize));
-	uint8_t *crcState = malloc(sizeof(uint8_t)*(2*listSize)); //0=False, 1=True
-
-	for (int i=0; i<(2*listSize); i++) {
-		pathMetric[i] = 0;
-		crcState[i]=1;
-	}
-	for (int i=0; i<polarParams->N; i++) {
-		llrUpdated[i][polarParams->n]=1;
-		bitUpdated[i][0]=((polarParams->information_bit_pattern[i]+1) % 2);
-	}
-
-	uint8_t **extended_crc_generator_matrix = malloc(polarParams->K * sizeof(uint8_t *)); //G_P3
-	uint8_t **tempECGM = malloc(polarParams->K * sizeof(uint8_t *)); //G_P2
-	for (int i = 0; i < polarParams->K; i++){
-		extended_crc_generator_matrix[i] = malloc(polarParams->crcParityBits * sizeof(uint8_t));
-		tempECGM[i] = malloc(polarParams->crcParityBits * sizeof(uint8_t));
-	}
-
-	for (int i=0; i<polarParams->payloadBits; i++) {
-		for (int j=0; j<polarParams->crcParityBits; j++) {
-			tempECGM[i][j]=polarParams->crc_generator_matrix[i][j];
-		}
-	}
-	for (int i=polarParams->payloadBits; i<polarParams->K; i++) {
-			for (int j=0; j<polarParams->crcParityBits; j++) {
-				if( (i-polarParams->payloadBits) == j ){
-					tempECGM[i][j]=1;
-				} else {
-					tempECGM[i][j]=0;
-				}
-			}
-	}
-
-	for (int i=0; i<polarParams->K; i++) {
-		for (int j=0; j<polarParams->crcParityBits; j++) {
-			extended_crc_generator_matrix[i][j]=tempECGM[polarParams->interleaving_pattern[i]][j];
-		}
-	}
-
-	//The index of the last 1-valued bit that appears in each column.
-	uint16_t last1ind[polarParams->crcParityBits];
-	for (int j=0; j<polarParams->crcParityBits; j++) {
-			for (int i=0; i<polarParams->K; i++) {
-				if (extended_crc_generator_matrix[i][j]==1) last1ind[j]=i;
-			}
-	}
-
-	double *d_tilde = malloc(sizeof(double) * polarParams->N);
-	nr_polar_rate_matching(input, d_tilde, polarParams->rate_matching_pattern, polarParams->K, polarParams->N, polarParams->encoderLength);
-	for (int j = 0; j < polarParams->N; j++) llr[j][polarParams->n][0]=d_tilde[j];
-
-
-	/*
-	 * SCL polar decoder.
-	 */
-
-	uint32_t nonFrozenBit=0;
-	uint8_t currentListSize=1;
-	uint8_t decoderIterationCheck=0;
-	int16_t checkCrcBits=-1;
-	uint8_t listIndex[2*listSize], copyIndex;
-
-	for (uint16_t currentBit=0; currentBit<polarParams->N; currentBit++){
-		updateLLR(llr, llrUpdated, bit, bitUpdated, currentListSize, currentBit, 0, polarParams->N, (polarParams->n+1), pathMetricAppr);
-		if (polarParams->information_bit_pattern[currentBit]==0) { //Frozen bit.
-			updatePathMetric(pathMetric, llr, currentListSize, 0, currentBit, pathMetricAppr); //approximation=0 --> 11b, approximation=1 --> 12
-		} else { //Information or CRC bit.
-			if ( (polarParams->interleaving_pattern[nonFrozenBit] <= polarParams->payloadBits) &&
-					(aPrioriPayload[polarParams->interleaving_pattern[nonFrozenBit]] == 0) ) {
-				//Information bit with known value of "0".
-				updatePathMetric(pathMetric, llr, currentListSize, 0, currentBit, pathMetricAppr);
-				bitUpdated[currentBit][0]=1; //0=False, 1=True
-			} else if ( (polarParams->interleaving_pattern[nonFrozenBit] <= polarParams->payloadBits) &&
-					(aPrioriPayload[polarParams->interleaving_pattern[nonFrozenBit]] == 1) ) {
-				//Information bit with known value of "1".
-				updatePathMetric(pathMetric, llr, currentListSize, 1, currentBit, pathMetricAppr);
-				for (uint8_t i=0; i<currentListSize; i++) bit[currentBit][0][i]=1;
-				bitUpdated[currentBit][0]=1;
-				updateCrcChecksum(crcChecksum, extended_crc_generator_matrix, currentListSize, nonFrozenBit, polarParams->crcParityBits);
-			} else {
-				updatePathMetric2(pathMetric, llr, currentListSize, currentBit, pathMetricAppr);
-
-				for (int i = 0; i < currentListSize; i++) {
-					for (int j = 0; j < polarParams->N; j++) {
-						for (int k = 0; k < (polarParams->n+1); k++) {
-							bit[j][k][i+currentListSize]=bit[j][k][i];
-							llr[j][k][i+currentListSize]=llr[j][k][i];}}}
-				for (int i = 0; i < currentListSize; i++) {
-					bit[currentBit][0][i]=0;
-					crcState[i+currentListSize]=crcState[i];
-				}
-				for (int i = currentListSize; i < 2*currentListSize; i++) bit[currentBit][0][i]=1;
-				bitUpdated[currentBit][0]=1;
-				updateCrcChecksum2(crcChecksum, extended_crc_generator_matrix, currentListSize, nonFrozenBit, polarParams->crcParityBits);
-				currentListSize*=2;
-
-				//Keep only the best "listSize" number of entries.
-				if (currentListSize > listSize) {
-					for (uint8_t i = 0; i < 2*listSize; i++) listIndex[i]=i;
-					nr_sort_asc_double_1D_array_ind(pathMetric, listIndex, currentListSize);
-
-					//sort listIndex[listSize, ..., 2*listSize-1] in descending order.
-					uint8_t swaps, tempInd;
-					for (uint8_t i = 0; i < listSize; i++) {
-						swaps = 0;
-						for (uint8_t j = listSize; j < (2*listSize - i) - 1; j++) {
-							if (listIndex[j+1] > listIndex[j]) {
-								tempInd = listIndex[j];
-								listIndex[j] = listIndex[j + 1];
-								listIndex[j + 1] = tempInd;
-								swaps++;
-							}
-						}
-						if (swaps == 0)
-							break;
-					}
-
-					//First, backup the best "listSize" number of entries.
-					for (int k=(listSize-1); k>0; k--) {
-						for (int i=0; i<polarParams->N; i++) {
-							for (int j=0; j<(polarParams->n+1); j++) {
-								bit[i][j][listIndex[(2*listSize-1)-k]]=bit[i][j][listIndex[k]];
-								llr[i][j][listIndex[(2*listSize-1)-k]]=llr[i][j][listIndex[k]];
-							}
-						}
-					}
-					for (int k=(listSize-1); k>0; k--) {
-						for (int i = 0; i < polarParams->crcParityBits; i++) {
-							crcChecksum[i][listIndex[(2*listSize-1)-k]] = crcChecksum[i][listIndex[k]];
-						}
-					}
-					for (int k=(listSize-1); k>0; k--) crcState[listIndex[(2*listSize-1)-k]]=crcState[listIndex[k]];
-
-					//Copy the best "listSize" number of entries to the first indices.
-					for (int k = 0; k < listSize; k++) {
-						if (k > listIndex[k]) {
-							copyIndex = listIndex[(2*listSize-1)-k];
-						} else { //Use the backup.
-							copyIndex = listIndex[k];
-						}
-						for (int i = 0; i < polarParams->N; i++) {
-							for (int j = 0; j < (polarParams->n + 1); j++) {
-								bit[i][j][k] = bit[i][j][copyIndex];
-								llr[i][j][k] = llr[i][j][copyIndex];
-							}
-						}
-					}
-					for (int k = 0; k < listSize; k++) {
-						if (k > listIndex[k]) {
-							copyIndex = listIndex[(2*listSize-1)-k];
-						} else { //Use the backup.
-							copyIndex = listIndex[k];
-						}
-						for (int i = 0; i < polarParams->crcParityBits; i++) {
-							crcChecksum[i][k]=crcChecksum[i][copyIndex];
-						}
-					}
-					for (int k = 0; k < listSize; k++) {
-						if (k > listIndex[k]) {
-							copyIndex = listIndex[(2*listSize-1)-k];
-						} else { //Use the backup.
-							copyIndex = listIndex[k];
-						}
-						crcState[k]=crcState[copyIndex];
-					}
-					currentListSize = listSize;
-				}
-			}
-
-			for (int i=0; i<polarParams->crcParityBits; i++) {
-				if (last1ind[i]==nonFrozenBit) {
-					checkCrcBits=i;
-					break;
-				}
-			}
-
-			if ( checkCrcBits > (-1) ) {
-				for (uint8_t i = 0; i < currentListSize; i++) {
-					if (crcChecksum[checkCrcBits][i]==1) {
-						crcState[i]=0; //0=False, 1=True
-					}
-				}
-			}
-
-			for (uint8_t i = 0; i < currentListSize; i++) decoderIterationCheck+=crcState[i];
-			if (decoderIterationCheck==0) {
-				//perror("[SCL polar decoder] All list entries have failed the CRC checks.");
-				free(d_tilde);
-				free(pathMetric);
-				free(crcState);
-				nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
-				nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-				nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
-				return(-1);
-			}
-
-			nonFrozenBit++;
-			decoderIterationCheck=0;
-			checkCrcBits=-1;
-		}
-	}
-
-	for (uint8_t i = 0; i < 2*listSize; i++) listIndex[i]=i;
-	nr_sort_asc_double_1D_array_ind(pathMetric, listIndex, currentListSize);
-
-	for (uint8_t i = 0; i < fmin(listSize, (pow(2,polarParams->crcCorrectionBits)) ); i++) {
-		if ( crcState[listIndex[i]] == 1 ) {
-			for (int j = 0; j < polarParams->N; j++) polarParams->nr_polar_U[j]=bit[j][0][listIndex[i]];
-
-			//Extract the information bits (û to ĉ)
-			nr_polar_info_bit_extraction(polarParams->nr_polar_U, polarParams->nr_polar_CPrime, polarParams->information_bit_pattern, polarParams->N);
-
-			//Deinterleaving (ĉ to b)
-			nr_polar_deinterleaver(polarParams->nr_polar_CPrime, polarParams->nr_polar_B, polarParams->interleaving_pattern, polarParams->K);
-
-			//Remove the CRC (â)
-			for (int j = 0; j < polarParams->payloadBits; j++) polarParams->nr_polar_A[j]=polarParams->nr_polar_B[j];
-
-			break;
-		}
-	}
-
-	free(d_tilde);
-	free(pathMetric);
-	free(crcState);
-	nr_free_uint8_3D_array(bit, polarParams->N, (polarParams->n+1));
-	nr_free_double_3D_array(llr, polarParams->N, (polarParams->n+1));
-	nr_free_uint8_2D_array(crcChecksum, polarParams->crcParityBits);
-	nr_free_uint8_2D_array(extended_crc_generator_matrix, polarParams->K);
-	nr_free_uint8_2D_array(tempECGM, polarParams->K);
-
-	/*
-	 * Return bits.
-	 */
-	nr_byte2bit_uint8_32_t(polarParams->nr_polar_A, polarParams->payloadBits, out);
+	nr_byte2bit_uint8_32(polarParams->nr_polar_A, polarParams->payloadBits, out);
 	return(0);
 }
 
-
 int8_t polar_decoder_dci(double *input,
 						 uint32_t *out,
 						 t_nrPolar_paramsPtr polarParams,
@@ -798,7 +538,6 @@ int8_t polar_decoder_dci(double *input,
 						 uint8_t pathMetricAppr,
 						 uint16_t n_RNTI)
 {
-
 	uint8_t ***bit = nr_alloc_uint8_3D_array(polarParams->N, (polarParams->n+1), 2*listSize);
 	uint8_t **bitUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
 	uint8_t **llrUpdated = nr_alloc_uint8_2D_array(polarParams->N, (polarParams->n+1)); //0=False, 1=True
@@ -1035,7 +774,7 @@ int8_t polar_decoder_dci(double *input,
 	/*
 	 * Return bits.
 	 */
-	nr_byte2bit_uint8_32_t(polarParams->nr_polar_A, polarParams->payloadBits, out);
+	nr_byte2bit_uint8_32(polarParams->nr_polar_A, polarParams->payloadBits, out);
 	return(0);
 }
 
@@ -1072,24 +811,20 @@ void init_polar_deinterleaver_table(t_nrPolar_params *polarParams) {
 }
 
 uint32_t polar_decoder_int16(int16_t *input,
-			     uint64_t *out,
-			     t_nrPolar_params *polarParams)
+							 uint64_t *out,
+							 t_nrPolar_params *polarParams)
 {
-  
-
-  
   int16_t d_tilde[polarParams->N];// = malloc(sizeof(double) * polarParams->N);
 
   nr_polar_rate_matching_int16(input, d_tilde, polarParams->rate_matching_pattern, polarParams->K, polarParams->N, polarParams->encoderLength);
   for (int i=0;i<polarParams->N;i++) {
-    if (d_tilde[i]<-128) d_tilde[i]=-128;
-    else if (d_tilde[i]>127) d_tilde[i]=128;
+	  if (d_tilde[i]<-128) d_tilde[i]=-128;
+	  else if (d_tilde[i]>127) d_tilde[i]=127;
   }
 
   memcpy((void*)&polarParams->tree.root->alpha[0],(void*)&d_tilde[0],sizeof(int16_t)*polarParams->N);
   
-  generic_polar_decoder(polarParams,polarParams->tree.root);
-
+  generic_polar_decoder(polarParams, polarParams->tree.root);
 
   //Extract the information bits (û to ĉ)
   uint64_t Cprime[4]={0,0,0,0};
@@ -1117,7 +852,6 @@ uint32_t polar_decoder_int16(int16_t *input,
     }
   }
 
-
   int len=polarParams->payloadBits;
   //int len_mod64=len&63;
   int crclen = polarParams->crcParityBits;
@@ -1160,9 +894,5 @@ uint32_t polar_decoder_int16(int16_t *input,
 
   out[0]=Ar;
 
-
   return(crc^rxcrc);
-  
-
-
 }
diff --git a/openair1/PHY/CODING/nrPolar_tools/nr_polar_decoding_tools.c b/openair1/PHY/CODING/nrPolar_tools/nr_polar_decoding_tools.c
index bec322b946..6ac29eb50b 100644
--- a/openair1/PHY/CODING/nrPolar_tools/nr_polar_decoding_tools.c
+++ b/openair1/PHY/CODING/nrPolar_tools/nr_polar_decoding_tools.c
@@ -37,15 +37,15 @@
 //#define DEBUG_NEW_IMPL 1
 
 void updateLLR(double ***llr,
-	       uint8_t **llrU,
-	       uint8_t ***bit,
-	       uint8_t **bitU,
-	       uint8_t listSize,
-	       uint16_t row,
-	       uint16_t col,
-	       uint16_t xlen,
-	       uint8_t ylen,
-	       uint8_t approximation)
+			   uint8_t **llrU,
+			   uint8_t ***bit,
+			   uint8_t **bitU,
+			   uint8_t listSize,
+			   uint16_t row,
+			   uint16_t col,
+			   uint16_t xlen,
+			   uint8_t ylen,
+		   	   uint8_t approximation)
 {
 	uint16_t offset = (xlen/(pow(2,(ylen-col-1))));
 	for (uint8_t i=0; i<listSize; i++) {
@@ -73,7 +73,6 @@ void updateBit(uint8_t ***bit,
 			   uint16_t xlen,
 			   uint8_t ylen)
 {
-
 	uint16_t offset = ( xlen/(pow(2,(ylen-col))) );
 
 	for (uint8_t i=0; i<listSize; i++) {
@@ -107,7 +106,6 @@ void updatePathMetric(double *pathMetric,
 	}
 }
 
-
 void updatePathMetric2(double *pathMetric,
 					   double ***llr,
 					   uint8_t listSize,
@@ -139,10 +137,7 @@ void updatePathMetric2(double *pathMetric,
 	}
 
 	free(tempPM);
-
-
-
-  }
+}
 
 void computeLLR(double ***llr,
 				uint16_t row,
@@ -161,8 +156,6 @@ void computeLLR(double ***llr,
 	} else { //eq. (8a)
 		llr[row][col][i] = log((exp(a + b) + 1) / (exp(a) + exp(b)));
 	}
-
-
 }
 
 void updateCrcChecksum(uint8_t **crcChecksum,
@@ -191,9 +184,16 @@ void updateCrcChecksum2(uint8_t **crcChecksum,
 	}
 }
 
+void build_decoder_tree(t_nrPolar_params *polarParams)
+{
+  polarParams->tree.num_nodes=0;
+  polarParams->tree.root = add_nodes(polarParams->n,0,polarParams);
+#ifdef DEBUG_NEW_IMPL
+  printf("root : left %p, right %p\n",polarParams->tree.root->left,polarParams->tree.root->right);
+#endif
+}
 
-
-decoder_node_t *new_decoder_node(int first_leaf_index,int level) {
+decoder_node_t *new_decoder_node(int first_leaf_index, int level) {
 
   decoder_node_t *node=(decoder_node_t *)malloc(sizeof(decoder_node_t));
 
@@ -208,32 +208,34 @@ decoder_node_t *new_decoder_node(int first_leaf_index,int level) {
   node->beta   = (int16_t*)malloc16(node->Nv*sizeof(int16_t));
   memset((void*)node->beta,-1,node->Nv*sizeof(int16_t));
   
-
   return(node);
 }
 
-decoder_node_t *add_nodes(int level,int first_leaf_index,t_nrPolar_params *pp) {
+decoder_node_t *add_nodes(int level, int first_leaf_index, t_nrPolar_params *polarParams) {
 
-  int all_frozen_below=1;
+  int all_frozen_below = 1;
   int Nv = 1<<level;
-  decoder_node_t *new_node = new_decoder_node(first_leaf_index,level);
+  decoder_node_t *new_node = new_decoder_node(first_leaf_index, level);
 #ifdef DEBUG_NEW_IMPL
-  printf("New node %d order %d, level %d\n",pp->tree.num_nodes,Nv,level);
+  printf("New node %d order %d, level %d\n",polarParams->tree.num_nodes,Nv,level);
 #endif
-  pp->tree.num_nodes++;
+  polarParams->tree.num_nodes++;
   if (level==0) {
 #ifdef DEBUG_NEW_IMPL
-    printf("leaf %d (%s)\n",first_leaf_index,pp->information_bit_pattern[first_leaf_index]==1 ? "information or crc" : "frozen");
+    printf("leaf %d (%s)\n", first_leaf_index, polarParams->information_bit_pattern[first_leaf_index]==1 ? "information or crc" : "frozen");
 #endif
     new_node->leaf=1;
-    new_node->all_frozen = pp->information_bit_pattern[first_leaf_index]==0 ? 1 : 0;
+    new_node->all_frozen = polarParams->information_bit_pattern[first_leaf_index]==0 ? 1 : 0;
     return new_node; // this is a leaf node
   }
 
   for (int i=0;i<Nv;i++) {
-    if (pp->information_bit_pattern[i+first_leaf_index]>0) all_frozen_below=0; 
+    if (polarParams->information_bit_pattern[i+first_leaf_index]>0)
+    	all_frozen_below=0;
   }
-  if (all_frozen_below==0) new_node->left=add_nodes(level-1,first_leaf_index,pp);
+
+  if (all_frozen_below==0)
+	  new_node->left=add_nodes(level-1, first_leaf_index, polarParams);
   else {
 #ifdef DEBUG_NEW_IMPL
     printf("aggregating frozen bits %d ... %d at level %d (%s)\n",first_leaf_index,first_leaf_index+Nv-1,level,((first_leaf_index/Nv)&1)==0?"left":"right");
@@ -241,22 +243,14 @@ decoder_node_t *add_nodes(int level,int first_leaf_index,t_nrPolar_params *pp) {
     new_node->leaf=1;
     new_node->all_frozen=1;
   }
-  if (all_frozen_below==0) new_node->right=add_nodes(level-1,first_leaf_index+(Nv/2),pp);
+  if (all_frozen_below==0)
+	  new_node->right=add_nodes(level-1,first_leaf_index+(Nv/2),polarParams);
 
 #ifdef DEBUG_NEW_IMPL
   printf("new_node (%d): first_leaf_index %d, left %p, right %p\n",Nv,first_leaf_index,new_node->left,new_node->right);
-#endif  
-  return(new_node);
-}
-
-
-void build_decoder_tree(t_nrPolar_params *pp) {
-
-  pp->tree.num_nodes=0;
-  pp->tree.root = add_nodes(pp->n,0,pp);
-#ifdef DEBUG_NEW_IMPL
-  printf("root : left %p, right %p\n",pp->tree.root->left,pp->tree.root->right);
 #endif
+
+  return(new_node);
 }
 
 #if defined(__arm__) || defined(__aarch64__)
@@ -271,7 +265,7 @@ void build_decoder_tree(t_nrPolar_params *pp) {
 #define _mm_subs_pi16(a,b) vsub_s16(a,b)
 #endif
 
-void applyFtoleft(t_nrPolar_params *pp,decoder_node_t *node) {
+void applyFtoleft(t_nrPolar_params *pp, decoder_node_t *node) {
   int16_t *alpha_v=node->alpha;
   int16_t *alpha_l=node->left->alpha;
   int16_t *betal = node->left->beta;
@@ -370,16 +364,16 @@ void applyFtoleft(t_nrPolar_params *pp,decoder_node_t *node) {
 #endif
     { // equvalent scalar code to above, activated only on non x86/ARM architectures
       for (int i=0;i<node->Nv/2;i++) {
-	a=alpha_v[i];
-	b=alpha_v[i+(node->Nv/2)];
-	maska=a>>15;
-	maskb=b>>15;
-	absa=(a+maska)^maska;
-	absb=(b+maskb)^maskb;
-	minabs = absa<absb ? absa : absb;
-	alpha_l[i] = (maska^maskb)==0 ? minabs : -minabs;
-	//	printf("alphal[%d] %d (%d,%d)\n",i,alpha_l[i],a,b);
-      }
+    	  a=alpha_v[i];
+    	  b=alpha_v[i+(node->Nv/2)];
+    	  maska=a>>15;
+    	  maskb=b>>15;
+    	  absa=(a+maska)^maska;
+    	  absb=(b+maskb)^maskb;
+    	  minabs = absa<absb ? absa : absb;
+    	  alpha_l[i] = (maska^maskb)==0 ? minabs : -minabs;
+    	  //	printf("alphal[%d] %d (%d,%d)\n",i,alpha_l[i],a,b);
+    	  }
     }
     if (node->Nv == 2) { // apply hard decision on left node
       betal[0] = (alpha_l[0]>0) ? -1 : 1;
@@ -463,11 +457,7 @@ void applyGtoright(t_nrPolar_params *pp,decoder_node_t *node) {
   }
 }
 
-
-int16_t all1[16] = {1,1,1,1,
-		    1,1,1,1,
-		    1,1,1,1,
-		    1,1,1,1};
+int16_t all1[16] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
 
 void computeBeta(t_nrPolar_params *pp,decoder_node_t *node) {
 
@@ -504,38 +494,35 @@ void computeBeta(t_nrPolar_params *pp,decoder_node_t *node) {
       int ssr4len = node->Nv/2/8;
       register __m128i allones=*((__m128i*)all1);
       for (int i=0;i<sse4len;i++) {
-      ((__m256i*)betav)[i] = _mm_or_si128(_mm_cmpeq_epi16(((__m128i*)betar)[i],
-							  ((__m128i*)betal)[i]),allones));
+      ((__m256i*)betav)[i] = _mm_or_si128(_mm_cmpeq_epi16(((__m128i*)betar)[i], ((__m128i*)betal)[i]),allones));
       }
     }
     else if (sse4mod == 4) {
-      ((__m64*)betav)[0] = _mm_or_si64(_mm_cmpeq_pi16(((__m64*)betar)[0],
-						      ((__m64*)betal)[0]),*((__m64*)all1));
+      ((__m64*)betav)[0] = _mm_or_si64(_mm_cmpeq_pi16(((__m64*)betar)[0], ((__m64*)betal)[0]),*((__m64*)all1));
     }
     else
 #endif
       {
 	for (int i=0;i<node->Nv/2;i++) {
-	  betav[i] = (betal[i] != betar[i]) ? 1 : -1;
+		betav[i] = (betal[i] != betar[i]) ? 1 : -1;
 	}
       }
   }
   else memcpy((void*)&betav[0],betar,(node->Nv/2)*sizeof(int16_t));
   memcpy((void*)&betav[node->Nv/2],betar,(node->Nv/2)*sizeof(int16_t));
-  
 }
 
-void generic_polar_decoder(t_nrPolar_params *pp,decoder_node_t *node) {
-
+void generic_polar_decoder(t_nrPolar_params *polarParams, decoder_node_t *node) {
 
   // Apply F to left
-  applyFtoleft(pp,node);
+  applyFtoleft(polarParams, node);
   // if left is not a leaf recurse down to the left
-  if (node->left->leaf==0) generic_polar_decoder(pp,node->left);
+  if (node->left->leaf==0)
+	  generic_polar_decoder(polarParams, node->left);
 
-  applyGtoright(pp,node);
-  if (node->right->leaf==0) generic_polar_decoder(pp,node->right);	
+  applyGtoright(polarParams, node);
+  if (node->right->leaf==0) generic_polar_decoder(polarParams, node->right);
 
-  computeBeta(pp,node);
+  computeBeta(polarParams, node);
 
 } 
diff --git a/openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h b/openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h
index bd056c3a18..76f1c322fe 100644
--- a/openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h
+++ b/openair1/PHY/CODING/nrPolar_tools/nr_polar_defs.h
@@ -54,8 +54,7 @@
 #define NR_POLAR_AGGREGATION_LEVEL_8_PRIME 163 //uint16_t
 #define NR_POLAR_AGGREGATION_LEVEL_16_PRIME 167 //uint16_t
 
-static const uint8_t nr_polar_subblock_interleaver_pattern[32] = { 0, 1, 2, 4, 3, 5, 6, 7, 8, 16, 9, 17, 10, 18, 11, 19, 12, 20, 13, 21, 14, 22, 15, 23, 24, 25, 26, 28, 27, 29, 30, 31 };
-
+static const uint8_t nr_polar_subblock_interleaver_pattern[32] = {0,1,2,4,3,5,6,7,8,16,9,17,10,18,11,19,12,20,13,21,14,22,15,23,24,25,26,28,27,29,30,31};
 
 #define Nmax 1024
 #define nmax 10
@@ -112,7 +111,7 @@ struct nrPolar_params {
   uint8_t **G_N;
   uint64_t **G_N_tab;
   int groupsize;
-  int     *rm_tab;
+  int *rm_tab;
   uint64_t cprime_tab0[32][256];
   uint64_t cprime_tab1[32][256];
   uint64_t B_tab0[32][256];
@@ -148,9 +147,9 @@ void polar_encoder_dci(uint32_t *in,
 					   uint16_t n_RNTI);
 
 void polar_encoder_fast(uint64_t *Aprime,
-			uint32_t *out,
-			int32_t crcmask,
-			t_nrPolar_paramsPtr polarParams);
+						uint32_t *out,
+						int32_t crcmask,
+						t_nrPolar_paramsPtr polarParams);
 
 int8_t polar_decoder(double *input,
 		 	 	 	 uint8_t *output,
@@ -158,10 +157,6 @@ int8_t polar_decoder(double *input,
 					 uint8_t listSize,
 					 uint8_t pathMetricAppr);
 
-uint32_t polar_decoder_int16(int16_t *input,
-			     uint64_t *out,
-			     t_nrPolar_params *polarParams);
-
 int8_t polar_decoder_aPriori(double *input,
 							 uint32_t *output,
 							 t_nrPolar_paramsPtr polarParams,
@@ -169,15 +164,6 @@ int8_t polar_decoder_aPriori(double *input,
 							 uint8_t pathMetricAppr,
 							 double *aPrioriPayload);
 
-int8_t polar_decoder_aPriori_timing(double *input,
-									uint32_t *output,
-									t_nrPolar_paramsPtr polarParams,
-									uint8_t listSize,
-									uint8_t pathMetricAppr,
-									double *aPrioriPayload,
-									double cpuFreqGHz,
-									FILE* logFile);
-
 int8_t polar_decoder_dci(double *input,
 						 uint32_t *out,
 						 t_nrPolar_paramsPtr polarParams,
@@ -185,11 +171,28 @@ int8_t polar_decoder_dci(double *input,
 						 uint8_t pathMetricAppr,
 						 uint16_t n_RNTI);
 
-void generic_polar_decoder(t_nrPolar_params *,
-		decoder_node_t *);
+uint32_t polar_decoder_int16(int16_t *input,
+							 uint64_t *out,
+							 t_nrPolar_params *polarParams);
+
+void generic_polar_decoder(t_nrPolar_params *, decoder_node_t *);
+
+void applyFtoleft(t_nrPolar_params *polarParams, decoder_node_t *node);
+
+void applyGtoright(t_nrPolar_params *polarParams, decoder_node_t *node);
+
+void computeBeta(t_nrPolar_params *polarParams, decoder_node_t *node);
+
+
+void build_decoder_tree(t_nrPolar_params *polarParams);
+
+decoder_node_t *new_decoder_node(int first_leaf_index, int level);
+
+decoder_node_t *add_nodes(int level, int first_leaf_index, t_nrPolar_params *polarParams);
+
 
-void build_decoder_tree(t_nrPolar_params *pp);
 void build_polar_tables(t_nrPolar_paramsPtr polarParams);
+
 void init_polar_deinterleaver_table(t_nrPolar_params *polarParams);
 
 void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
@@ -216,168 +219,143 @@ const uint16_t* nr_polar_sequence_pattern(uint8_t n);
  * @param E
  * @param n_max */
 uint32_t nr_polar_output_length(uint16_t K,
-		uint16_t E,
-		uint8_t n_max);
+								uint16_t E,
+								uint8_t n_max);
 
 void nr_polar_channel_interleaver_pattern(uint16_t *cip,
-		uint8_t I_BIL,
-		uint16_t E);
+										  uint8_t I_BIL,
+										  uint16_t E);
 
 void nr_polar_rate_matching_pattern(uint16_t *rmp,
-		uint16_t *J,
-		const uint8_t *P_i_,
-		uint16_t K,
-		uint16_t N,
-		uint16_t E);
+									uint16_t *J,
+									const uint8_t *P_i_,
+									uint16_t K,
+									uint16_t N,
+									uint16_t E);
 
 void nr_polar_rate_matching(double *input,
-		double *output,
-		uint16_t *rmp,
-		uint16_t K,
-		uint16_t N,
-		uint16_t E);
+							double *output,
+							uint16_t *rmp,
+							uint16_t K,
+							uint16_t N,
+							uint16_t E);
 
 void nr_polar_rate_matching_int16(int16_t *input,
-		int16_t *output,
-		uint16_t *rmp,
-		uint16_t K,
-		uint16_t N,
-		uint16_t E);
+								  int16_t *output,
+								  uint16_t *rmp,
+								  uint16_t K,
+								  uint16_t N,
+								  uint16_t E);
 
-void nr_polar_interleaving_pattern(uint16_t K,
-		uint8_t I_IL,
-		uint16_t *PI_k_);
+void nr_polar_interleaving_pattern(uint16_t K, uint8_t I_IL, uint16_t *PI_k_);
 
 void nr_polar_info_bit_pattern(uint8_t *ibp,
-		int16_t *Q_I_N,
-		int16_t *Q_F_N,
-		uint16_t *J,
-		const uint16_t *Q_0_Nminus1,
-		uint16_t K,
-		uint16_t N,
-		uint16_t E,
-		uint8_t n_PC);
+							   int16_t *Q_I_N,
+							   int16_t *Q_F_N,
+							   uint16_t *J,
+							   const uint16_t *Q_0_Nminus1,
+							   uint16_t K,
+							   uint16_t N,
+							   uint16_t E,
+							   uint8_t n_PC);
 
 void nr_polar_info_bit_extraction(uint8_t *input,
-		uint8_t *output,
-		uint8_t *pattern,
-		uint16_t size);
+								  uint8_t *output,
+								  uint8_t *pattern,
+								  uint16_t size);
 
-void nr_bit2byte_uint32_8_t(uint32_t *in,
-		uint16_t arraySize,
-		uint8_t *out);
+void nr_bit2byte_uint32_8(uint32_t *in, uint16_t arraySize, uint8_t *out);
 
-void nr_byte2bit_uint8_32_t(uint8_t *in,
-		uint16_t arraySize,
-		uint32_t *out);
+void nr_byte2bit_uint8_32(uint8_t *in, uint16_t arraySize, uint32_t *out);
 
-void nr_crc_bit2bit_uint32_8_t(uint32_t *in,
-		uint16_t arraySize,
-		uint8_t *out);
+void nr_crc_bit2bit_uint32_8(uint32_t *in, uint16_t arraySize, uint8_t *out);
 
 void nr_polar_bit_insertion(uint8_t *input,
-		uint8_t *output,
-		uint16_t N,
-		uint16_t K,
-		int16_t *Q_I_N,
-		int16_t *Q_PC_N,
-		uint8_t n_PC);
+							uint8_t *output,
+							uint16_t N,
+							uint16_t K,
+							int16_t *Q_I_N,
+							int16_t *Q_PC_N,
+							uint8_t n_PC);
 
 void nr_matrix_multiplication_uint8_1D_uint8_2D(uint8_t *matrix1,
-		uint8_t **matrix2,
-		uint8_t *output,
-		uint16_t row,
-		uint16_t col);
+												uint8_t **matrix2,
+												uint8_t *output,
+												uint16_t row,
+												uint16_t col);
 
-uint8_t ***nr_alloc_uint8_3D_array(uint16_t xlen,
-		uint16_t ylen,
-		uint16_t zlen);
+uint8_t ***nr_alloc_uint8_3D_array(uint16_t xlen, uint16_t ylen, uint16_t zlen);
 
-uint8_t **nr_alloc_uint8_2D_array(uint16_t xlen,
-		uint16_t ylen);
+uint8_t **nr_alloc_uint8_2D_array(uint16_t xlen, uint16_t ylen);
 
-double ***nr_alloc_double_3D_array(uint16_t xlen,
-		uint16_t ylen,
-		uint16_t zlen);
+double ***nr_alloc_double_3D_array(uint16_t xlen, uint16_t ylen, uint16_t zlen);
 
-double **nr_alloc_double_2D_array(uint16_t xlen,
-		uint16_t ylen);
+double **nr_alloc_double_2D_array(uint16_t xlen, uint16_t ylen);
 
-void nr_free_double_3D_array(double ***input,
-		uint16_t xlen,
-		uint16_t ylen);
-
-void nr_free_double_2D_array(double **input,
-		uint16_t xlen);
-
-void nr_free_uint8_3D_array(uint8_t ***input,
-		uint16_t xlen,
-		uint16_t ylen);
-
-void nr_free_uint8_2D_array(uint8_t **input,
-		uint16_t xlen);
-
-void nr_sort_asc_double_1D_array_ind(double *matrix,
-		uint8_t *ind,
-		uint8_t len);
-
-void nr_sort_asc_int16_1D_array_ind(int32_t *matrix,
-		int *ind,
-		int len);
+void nr_free_double_3D_array(double ***input, uint16_t xlen, uint16_t ylen);
 
 void nr_free_double_2D_array(double **input, uint16_t xlen);
 
+void nr_free_uint8_3D_array(uint8_t ***input, uint16_t xlen, uint16_t ylen);
+
+void nr_free_uint8_2D_array(uint8_t **input, uint16_t xlen);
+
+void nr_sort_asc_double_1D_array_ind(double *matrix, uint8_t *ind, uint8_t len);
+
+void nr_sort_asc_int16_1D_array_ind(int32_t *matrix, int *ind, int len);
+
+void nr_free_double_2D_array(double **input, uint16_t xlen);
 
 void updateLLR(double ***llr,
-		uint8_t **llrU,
-		uint8_t ***bit,
-		uint8_t **bitU,
-		uint8_t listSize,
-		uint16_t row,
-		uint16_t col,
-		uint16_t xlen,
-		uint8_t ylen,
-		uint8_t approximation);
+			   uint8_t **llrU,
+			   uint8_t ***bit,
+			   uint8_t **bitU,
+			   uint8_t listSize,
+			   uint16_t row,
+			   uint16_t col,
+			   uint16_t xlen,
+			   uint8_t ylen,
+			   uint8_t approximation);
 
 void updateBit(uint8_t ***bit,
-		uint8_t **bitU,
-		uint8_t listSize,
-		uint16_t row,
-		uint16_t col,
-		uint16_t xlen,
-		uint8_t ylen);
+			   uint8_t **bitU,
+			   uint8_t listSize,
+			   uint16_t row,
+			   uint16_t col,
+			   uint16_t xlen,
+			   uint8_t ylen);
 
 void updatePathMetric(double *pathMetric,
-		double ***llr,
-		uint8_t listSize,
-		uint8_t bitValue,
-		uint16_t row,
-		uint8_t approximation);
+					  double ***llr,
+					  uint8_t listSize,
+					  uint8_t bitValue,
+					  uint16_t row,
+					  uint8_t approximation);
 
 void updatePathMetric2(double *pathMetric,
-		double ***llr,
-		uint8_t listSize,
-		uint16_t row,
-		uint8_t approximation);
+					   double ***llr,
+					   uint8_t listSize,
+					   uint16_t row,
+					   uint8_t approximation);
 
 void computeLLR(double ***llr,
-		uint16_t row,
-		uint16_t col,
-		uint8_t i,
-		uint16_t offset,
-		uint8_t approximation);
+				uint16_t row,
+				uint16_t col,
+				uint8_t i,
+				uint16_t offset,
+				uint8_t approximation);
 
 void updateCrcChecksum(uint8_t **crcChecksum,
-		uint8_t **crcGen,
-		uint8_t listSize,
-		uint32_t i2,
-		uint8_t len);
+					   uint8_t **crcGen,
+					   uint8_t listSize,
+					   uint32_t i2,
+					   uint8_t len);
 
 void updateCrcChecksum2(uint8_t **crcChecksum,
-		uint8_t **crcGen,
-		uint8_t listSize,
-		uint32_t i2,
-		uint8_t len);
+					    uint8_t **crcGen,
+						uint8_t listSize,
+						uint32_t i2,
+						uint8_t len);
 
 uint8_t **crc24c_generator_matrix(uint16_t payloadSizeBits);
 
@@ -386,24 +364,14 @@ uint8_t **crc11_generator_matrix(uint16_t payloadSizeBits);
 uint8_t **crc6_generator_matrix(uint16_t payloadSizeBits);
 
 //Also nr_polar_rate_matcher
-static inline void nr_polar_interleaver(uint8_t *input,
-					uint8_t *output,
-					uint16_t *pattern,
-					uint16_t size)
-{
-  for (int i=0; i<size; i++) output[i]=input[pattern[i]];
+static inline void nr_polar_interleaver(uint8_t *input,	uint8_t *output, uint16_t *pattern,	uint16_t size){
+  for (int i=0; i<size; i++)
+	  output[i]=input[pattern[i]];
 }
 
-static inline void nr_polar_deinterleaver(uint8_t *input,
-					  uint8_t *output,
-					  uint16_t *pattern,
-					  uint16_t size)
-{
-  for (int i=0; i<size; i++) {
-    output[pattern[i]]=input[i];
-  }
+static inline void nr_polar_deinterleaver(uint8_t *input, uint8_t *output, uint16_t *pattern, uint16_t size){
+  for (int i=0; i<size; i++)
+	  output[pattern[i]]=input[i];
 }
 
-void build_decoder_tree(t_nrPolar_params *pp);
-
 #endif
diff --git a/openair1/PHY/CODING/nrPolar_tools/nr_polar_encoder.c b/openair1/PHY/CODING/nrPolar_tools/nr_polar_encoder.c
index bafddae850..141ec6615b 100644
--- a/openair1/PHY/CODING/nrPolar_tools/nr_polar_encoder.c
+++ b/openair1/PHY/CODING/nrPolar_tools/nr_polar_encoder.c
@@ -33,7 +33,7 @@
 //#define DEBUG_POLAR_ENCODER
 //#define DEBUG_POLAR_ENCODER_DCI
 //#define DEBUG_POLAR_ENCODER_TIMING
-#define DEBUG_POLAR_MATLAB
+//#define DEBUG_POLAR_MATLAB
 
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 #include "assertions.h"
@@ -51,9 +51,9 @@ void polar_encoder(uint32_t *in,
 #ifdef DEBUG_POLAR_ENCODER
     printf("polar_B %llx (crc %x)\n",B,crc24c((uint8_t*)in,polarParams->payloadBits)>>8);
 #endif
-nr_bit2byte_uint32_8_t((uint32_t*)&B, polarParams->K, polarParams->nr_polar_B);*/
+nr_bit2byte_uint32_8((uint32_t*)&B, polarParams->K, polarParams->nr_polar_B);*/
 
-    nr_bit2byte_uint32_8_t((uint32_t*)in, polarParams->payloadBits, polarParams->nr_polar_A);
+    nr_bit2byte_uint32_8((uint32_t*)in, polarParams->payloadBits, polarParams->nr_polar_A);
     /*
      * Bytewise operations
      */
@@ -147,7 +147,7 @@ nr_bit2byte_uint32_8_t((uint32_t*)&B, polarParams->K, polarParams->nr_polar_B);*
   for (int i=0; i< polarParams->encoderLength;i++) printf("f[%d]=%d\n", i, polarParams->nr_polar_E[i]);
 #endif
 
-  nr_byte2bit_uint8_32_t(polarParams->nr_polar_E, polarParams->encoderLength, out);
+  nr_byte2bit_uint8_32(polarParams->nr_polar_E, polarParams->encoderLength, out);
 }
 
 void polar_encoder_dci(uint32_t *in,
@@ -163,7 +163,7 @@ void polar_encoder_dci(uint32_t *in,
    * Bytewise operations
    */
   //(a to a')
-  nr_bit2byte_uint32_8_t(in, polarParams->payloadBits, polarParams->nr_polar_A);
+  nr_bit2byte_uint32_8(in, polarParams->payloadBits, polarParams->nr_polar_A);
   for (int i=0; i<polarParams->crcParityBits; i++) polarParams->nr_polar_APrime[i]=1;
   for (int i=0; i<polarParams->payloadBits; i++) polarParams->nr_polar_APrime[i+(polarParams->crcParityBits)]=polarParams->nr_polar_A[i];
 #ifdef DEBUG_POLAR_ENCODER_DCI
@@ -202,7 +202,7 @@ void polar_encoder_dci(uint32_t *in,
   }
 
   /*	//(a to a')
-	nr_crc_bit2bit_uint32_8_t(in, polarParams->payloadBits, polarParams->nr_polar_aPrime);
+	nr_crc_bit2bit_uint32_8(in, polarParams->payloadBits, polarParams->nr_polar_aPrime);
 	//Parity bits computation (p)
 	polarParams->crcBit = crc24c(polarParams->nr_polar_aPrime, (polarParams->payloadBits+polarParams->crcParityBits));
 	#ifdef DEBUG_POLAR_ENCODER_DCI
@@ -273,7 +273,7 @@ void polar_encoder_dci(uint32_t *in,
   /*
    * Return bits.
    */
-  nr_byte2bit_uint8_32_t(polarParams->nr_polar_E, polarParams->encoderLength, out);
+  nr_byte2bit_uint8_32(polarParams->nr_polar_E, polarParams->encoderLength, out);
 #ifdef DEBUG_POLAR_ENCODER_DCI
   printf("[polar_encoder_dci] E: ");
   for (int i = 0; i < polarParams->encoderLength; i++) printf("%d-", polarParams->nr_polar_E[i]);
diff --git a/openair1/PHY/CODING/nrPolar_tools/nr_polar_procedures.c b/openair1/PHY/CODING/nrPolar_tools/nr_polar_procedures.c
index 985266447b..fd7793ca79 100644
--- a/openair1/PHY/CODING/nrPolar_tools/nr_polar_procedures.c
+++ b/openair1/PHY/CODING/nrPolar_tools/nr_polar_procedures.c
@@ -33,12 +33,12 @@
 #include "PHY/CODING/nrPolar_tools/nr_polar_defs.h"
 
 void nr_polar_bit_insertion(uint8_t *input,
-			    uint8_t *output,
-			    uint16_t N,
-			    uint16_t K,
-			    int16_t *Q_I_N,
-			    int16_t *Q_PC_N,
-			    uint8_t n_PC)
+			    			uint8_t *output,
+							uint16_t N,
+							uint16_t K,
+							int16_t *Q_I_N,
+							int16_t *Q_PC_N,
+							uint8_t n_PC)
 {
   uint16_t k=0;
   uint8_t flag;
@@ -256,8 +256,13 @@ void nr_polar_info_bit_extraction(uint8_t *input,
 }
 
 
-void nr_polar_rate_matching_pattern(uint16_t *rmp, uint16_t *J, const uint8_t *P_i_, uint16_t K, uint16_t N, uint16_t E){
-
+void nr_polar_rate_matching_pattern(uint16_t *rmp,
+									uint16_t *J,
+									const uint8_t *P_i_,
+									uint16_t K,
+									uint16_t N,
+									uint16_t E)
+{
 	uint8_t i;
 	uint16_t *d, *y, ind;
 	d = (uint16_t *)malloc(sizeof(uint16_t) * N);
@@ -293,8 +298,13 @@ void nr_polar_rate_matching_pattern(uint16_t *rmp, uint16_t *J, const uint8_t *P
 }
 
 
-void nr_polar_rate_matching(double *input, double *output, uint16_t *rmp, uint16_t K, uint16_t N, uint16_t E){
-
+void nr_polar_rate_matching(double *input,
+							double *output,
+							uint16_t *rmp,
+							uint16_t K,
+							uint16_t N,
+							uint16_t E)
+{
 	if (E>=N) { //repetition
 		for (int i=0; i<=N-1; i++) output[i]=0;
 		for (int i=0; i<=E-1; i++){
@@ -311,11 +321,15 @@ void nr_polar_rate_matching(double *input, double *output, uint16_t *rmp, uint16
 			output[rmp[i]]=input[i];
 		}
 	}
-
 }
 
-void nr_polar_rate_matching_int16(int16_t *input, int16_t *output, uint16_t *rmp, uint16_t K, uint16_t N, uint16_t E){
-
+void nr_polar_rate_matching_int16(int16_t *input,
+								  int16_t *output,
+								  uint16_t *rmp,
+								  uint16_t K,
+								  uint16_t N,
+								  uint16_t E)
+{
 	if (E>=N) { //repetition
 		for (int i=0; i<=N-1; i++) output[i]=0;
 		for (int i=0; i<=E-1; i++){
@@ -332,6 +346,4 @@ void nr_polar_rate_matching_int16(int16_t *input, int16_t *output, uint16_t *rmp
 			output[rmp[i]]=input[i];
 		}
 	}
-
 }
-
diff --git a/openair1/PHY/CODING/nrSmallBlock/decodeSmallBlock.c b/openair1/PHY/CODING/nrSmallBlock/decodeSmallBlock.c
new file mode 100644
index 0000000000..95237ea40b
--- /dev/null
+++ b/openair1/PHY/CODING/nrSmallBlock/decodeSmallBlock.c
@@ -0,0 +1,117 @@
+/*
+ * 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 PHY/CODING/nrSmallBlock/decodeSmallBlock.c
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2019
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
+#include "PHY/CODING/nrSmallBlock/nr_small_block_defs.h"
+#include "assertions.h"
+#include "PHY/sse_intrin.h"
+
+//#define DEBUG_DECODESMALLBLOCK
+
+uint16_t decodeSmallBlock(int8_t *in, uint8_t len){
+	uint16_t out = 0;
+
+	AssertFatal(len >= 3 && len <= 11, "[decodeSmallBlock] Message Length = %d (Small Block Coding is only defined for input lengths 3 to 11)", len);
+
+	if(len<7) {
+		int16_t Rhat[NR_SMALL_BLOCK_CODED_BITS] = {0}, Rhatabs[NR_SMALL_BLOCK_CODED_BITS] = {0};
+		uint16_t maxVal;
+		uint8_t maxInd = 0;
+
+		for (int j = 0; j < NR_SMALL_BLOCK_CODED_BITS; ++j)
+			for (int k = 0; k < NR_SMALL_BLOCK_CODED_BITS; ++k)
+				Rhat[j] += in[k] * hadamard32InterleavedTransposed[j][k];
+
+#if defined(__AVX2__)
+		for (int i = 0; i < NR_SMALL_BLOCK_CODED_BITS; i += 16) {
+			__m256i a15_a0 = _mm256_loadu_si256((__m256i*)&Rhat[i]);
+			a15_a0 = _mm256_abs_epi16(a15_a0);
+			_mm256_storeu_si256((__m256i*)(&Rhatabs[i]), a15_a0);
+		}
+#else
+		for (int i = 0; i < NR_SMALL_BLOCK_CODED_BITS; i += 8) {
+			__m128i a7_a0 = _mm_loadu_si128((__m128i*)&Rhat[i]);
+			a7_a0 = _mm_abs_epi16(a7_a0);
+			_mm_storeu_si128((__m128i*)(&Rhatabs[i]), a7_a0);
+		}
+#endif
+		maxVal = Rhatabs[0];
+		for (int k = 1; k < NR_SMALL_BLOCK_CODED_BITS; ++k){
+			if (Rhatabs[k] > maxVal){
+				maxVal = Rhatabs[k];
+				maxInd = k;
+			}
+		}
+
+		out = properOrderedBasis[maxInd] | ( (Rhat[maxInd] > 0) ? (uint16_t)0 : (uint16_t)1 );
+
+#ifdef DEBUG_DECODESMALLBLOCK
+		for (int k = 0; k < NR_SMALL_BLOCK_CODED_BITS; ++k)
+			printf("[decodeSmallBlock]Rhat[%d]=%d %d %d %d\n",k, Rhat[k], maxVal, maxInd, ((uint32_t)out>>k)&1);
+		printf("[decodeSmallBlock]0x%x 0x%x\n", out, properOrderedBasis[maxInd]);
+#endif
+
+	} else {
+		int8_t Dmatrix[NR_SMALL_BLOCK_CODED_BITS][NR_SMALL_BLOCK_CODED_BITS] = {0};
+		int16_t DmatrixFHT[NR_SMALL_BLOCK_CODED_BITS][NR_SMALL_BLOCK_CODED_BITS] = {0};
+		uint16_t maxVal;
+		uint8_t maxRow = 0, maxCol = 0;
+
+		for (int j = 0; j < NR_SMALL_BLOCK_CODED_BITS; ++j)
+			for (int k = 0; k < NR_SMALL_BLOCK_CODED_BITS; ++k)
+				Dmatrix[j][k] = in[k] * maskD[j][k];
+
+
+		for (int i = 0; i < NR_SMALL_BLOCK_CODED_BITS; ++i)
+			for (int j = 0; j < NR_SMALL_BLOCK_CODED_BITS; ++j)
+				for (int k = 0; k < NR_SMALL_BLOCK_CODED_BITS; ++k)
+					DmatrixFHT[i][j] += Dmatrix[i][k] * hadamard32InterleavedTransposed[j][k];
+
+		maxVal = abs(DmatrixFHT[0][0]);
+		for (int i = 0; i < NR_SMALL_BLOCK_CODED_BITS; ++i)
+			for (int j = 0; j < NR_SMALL_BLOCK_CODED_BITS; ++j)
+				if (abs(DmatrixFHT[i][j]) > maxVal){
+					maxVal = abs(DmatrixFHT[i][j]);
+					maxRow = i;
+					maxCol = j;
+				}
+
+		out = properOrderedBasisExtended[maxRow] | properOrderedBasis[maxCol] | ( (DmatrixFHT[maxRow][maxCol] > 0) ? (uint16_t)0 : (uint16_t)1 );
+
+#ifdef DEBUG_DECODESMALLBLOCK
+		for (int k = 0; k < NR_SMALL_BLOCK_CODED_BITS; ++k)
+					printf("[decodeSmallBlock]maxRow = %d maxCol = %d out[%d]=%d\n", maxRow, maxCol, k, ((uint32_t)out>>k)&1);
+#endif
+
+	}
+
+	return out;
+}
diff --git a/openair1/PHY/CODING/nrSmallBlock/encodeSmall.c b/openair1/PHY/CODING/nrSmallBlock/encodeSmall.c
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/openair1/PHY/CODING/nrSmallBlock/encodeSmallBlock.c b/openair1/PHY/CODING/nrSmallBlock/encodeSmallBlock.c
new file mode 100644
index 0000000000..8358bd270b
--- /dev/null
+++ b/openair1/PHY/CODING/nrSmallBlock/encodeSmallBlock.c
@@ -0,0 +1,44 @@
+/*
+ * 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 PHY/CODING/nrSmallBlock/encodeSmallBlock.c
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2019
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
+#include "PHY/CODING/nrSmallBlock/nr_small_block_defs.h"
+
+//input = [0 ... 0 c_K-1 ... c_2 c_1 c_0]
+//output = [d_31 d_30 ... d_2 d_1 d_0]
+uint32_t encodeSmallBlock(uint16_t *in, uint8_t len){
+	uint32_t out = 0;
+	  for (uint16_t i=0; i<len; i++)
+	    if ((*in & (1<<i)) > 0)
+	    	out^=nrSmallBlockBasis[i];
+
+	  return out;
+}
diff --git a/openair1/PHY/CODING/nrSmallBlock/nr_small_block_defs.h b/openair1/PHY/CODING/nrSmallBlock/nr_small_block_defs.h
new file mode 100644
index 0000000000..50559aa0d2
--- /dev/null
+++ b/openair1/PHY/CODING/nrSmallBlock/nr_small_block_defs.h
@@ -0,0 +1,134 @@
+/*
+ * 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 PHY/CODING/nrSmallBlock/nr_small_block_defs.h
+ * \brief
+ * \author Turker Yilmaz
+ * \date 2019
+ * \version 0.1
+ * \company EURECOM
+ * \email turker.yilmaz@eurecom.fr
+ * \note
+ * \warning
+*/
+
+#ifndef __NR_SMALL_BLOCK_DEFS__H__
+#define __NR_SMALL_BLOCK_DEFS__H__
+
+#include <math.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define NR_SMALL_BLOCK_CODED_BITS 32
+
+#define L1d_CLS 64
+
+uint32_t encodeSmallBlock(uint16_t *in, uint8_t len);
+
+uint16_t decodeSmallBlock(int8_t *in, uint8_t len);
+
+static const uint32_t nrSmallBlockBasis[11] = {0xFFFFFFFF, 0x4BA5A933, 0x7D910E5A, 0x6D26339C, 0x71C7C3E0,
+		0x7E0FFC00, 0x731D8E64, 0x6B44F5B0, 0x7DC218EC, 0x4DA1B746, 0x42F0FFFF};
+
+static const uint16_t properOrderedBasis[32] = {0x0000, 0x0002, 0x0004, 0x0006, 0x0008, 0x000A, 0x000C, 0x000E, 0x0010, 0x0012,
+		0x0014, 0x0016, 0x0018, 0x001A, 0x001C, 0x001E, 0x0020, 0x0022, 0x0024, 0x0026,
+		0x0028, 0x002A, 0x002C, 0x002E, 0x0030, 0x0032, 0x0034, 0x0036, 0x0038, 0x003A, 0x003C, 0x003E};
+
+static const uint16_t properOrderedBasisExtended[32] = {0x0000, 0x0040, 0x0080, 0x00C0, 0x0100, 0x0140, 0x0180, 0x01C0, 0x0200, 0x0240,
+		0x0280, 0x02C0, 0x0300, 0x0340, 0x0380, 0x03C0, 0x0400, 0x0440, 0x0480, 0x04C0,
+		0x0500, 0x0540, 0x0580, 0x05C0, 0x0600, 0x0640, 0x0680, 0x06C0, 0x0700, 0x0740, 0x0780, 0x07C0};
+
+static const int8_t hadamard32InterleavedTransposed[32][32] __attribute__ ((aligned(32))) = {
+		{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
+		{-1,-1,1,1,-1,-1,1,1,-1,1,1,-1,1,-1,1,-1,-1,1,-1,1,1,-1,1,-1,-1,-1,1,-1,1,1,-1,1},
+		{1,-1,1,-1,-1,1,-1,1,1,-1,-1,-1,1,1,1,1,-1,1,1,1,-1,1,1,-1,-1,1,-1,-1,-1,-1,-1,1},
+		{-1,1,1,-1,1,-1,-1,1,-1,-1,-1,1,1,-1,1,-1,1,1,-1,1,-1,-1,1,1,1,-1,-1,1,-1,-1,1,1},
+		{1,1,-1,-1,-1,1,1,-1,-1,-1,1,1,-1,-1,1,1,1,-1,-1,1,1,-1,1,1,-1,1,-1,-1,1,-1,-1,1},
+		{-1,-1,-1,-1,1,-1,1,-1,1,-1,1,-1,-1,1,1,-1,-1,-1,1,1,1,1,1,-1,1,-1,-1,1,1,-1,1,1},
+		{1,-1,-1,1,1,1,-1,-1,-1,1,-1,-1,-1,-1,1,1,-1,-1,-1,1,-1,-1,1,-1,1,1,1,1,-1,1,1,1},
+		{-1,1,-1,1,-1,-1,-1,-1,1,1,-1,1,-1,1,1,-1,1,-1,1,1,-1,1,1,1,-1,-1,1,-1,-1,1,-1,1},
+		{1,1,1,1,1,-1,-1,-1,-1,-1,1,1,1,1,-1,-1,-1,-1,-1,1,1,1,-1,-1,-1,1,1,1,-1,-1,-1,1},
+		{-1,-1,1,1,-1,1,-1,-1,1,-1,1,-1,1,-1,-1,1,1,-1,1,1,1,-1,-1,1,1,-1,1,-1,-1,-1,1,1},
+		{1,-1,1,-1,-1,-1,1,-1,-1,1,-1,-1,1,1,-1,-1,1,-1,-1,1,-1,1,-1,1,1,1,-1,-1,1,1,1,1},
+		{-1,1,1,-1,1,1,1,-1,1,1,-1,1,1,-1,-1,1,-1,-1,1,1,-1,-1,-1,-1,-1,-1,-1,1,1,1,-1,1},
+		{1,1,-1,-1,-1,-1,-1,1,1,1,1,1,-1,-1,-1,-1,-1,1,1,1,1,-1,-1,-1,1,1,-1,-1,-1,1,1,1},
+		{-1,-1,-1,-1,1,1,-1,1,-1,1,1,-1,-1,1,-1,1,1,1,-1,1,1,1,-1,1,-1,-1,-1,1,-1,1,-1,1},
+		{1,-1,-1,1,1,-1,1,1,1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1,-1,-1,-1,1,-1,1,1,1,1,-1,-1,1},
+		{-1,1,-1,1,-1,1,1,1,-1,-1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,-1,1,-1,1,-1,1,-1,1,1},
+		{1,1,1,1,1,1,1,1,1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1,1,-1,-1,-1,-1,-1,-1,1},
+		{-1,-1,1,1,-1,-1,1,1,-1,1,-1,1,-1,1,-1,1,1,-1,1,-1,1,-1,1,-1,-1,1,-1,1,-1,-1,1,1},
+		{1,-1,1,-1,-1,1,-1,1,1,-1,1,1,-1,-1,-1,-1,1,-1,-1,-1,-1,1,1,-1,-1,-1,1,1,1,1,1,1},
+		{-1,1,1,-1,1,-1,-1,1,-1,-1,1,-1,-1,1,-1,1,-1,-1,1,-1,-1,-1,1,1,1,1,1,-1,1,1,-1,1},
+		{1,1,-1,-1,-1,1,1,-1,-1,-1,-1,-1,1,1,-1,-1,-1,1,1,-1,1,-1,1,1,-1,-1,1,1,-1,1,1,1},
+		{-1,-1,-1,-1,1,-1,1,-1,1,-1,-1,1,1,-1,-1,1,1,1,-1,-1,1,1,1,-1,1,1,1,-1,-1,1,-1,1},
+		{1,-1,-1,1,1,1,-1,-1,-1,1,1,1,1,1,-1,-1,1,1,1,-1,-1,-1,1,-1,1,-1,-1,-1,1,-1,-1,1},
+		{-1,1,-1,1,-1,-1,-1,-1,1,1,1,-1,1,-1,-1,1,-1,1,-1,-1,-1,1,1,1,-1,1,-1,1,1,-1,1,1},
+		{1,1,1,1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1,1,-1,1,1,-1,-1,-1,-1,-1,-1,1,1,1,1},
+		{-1,-1,1,1,-1,1,-1,-1,1,-1,-1,1,-1,1,1,-1,-1,1,-1,-1,1,-1,-1,1,1,1,-1,1,1,1,-1,1},
+		{1,-1,1,-1,-1,-1,1,-1,-1,1,1,1,-1,-1,1,1,-1,1,1,-1,-1,1,-1,1,1,-1,1,1,-1,-1,-1,1},
+		{-1,1,1,-1,1,1,1,-1,1,1,1,-1,-1,1,1,-1,1,1,-1,-1,-1,-1,-1,-1,-1,1,1,-1,-1,-1,1,1},
+		{1,1,-1,-1,-1,-1,-1,1,1,1,-1,-1,1,1,1,1,1,-1,-1,-1,1,-1,-1,-1,1,-1,1,1,1,-1,-1,1},
+		{-1,-1,-1,-1,1,1,-1,1,-1,1,-1,1,1,-1,1,-1,-1,-1,1,-1,1,1,-1,1,-1,1,1,-1,1,-1,1,1},
+		{1,-1,-1,1,1,-1,1,1,1,-1,1,1,1,1,1,1,-1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,-1,-1,1,1,1},
+		{-1,1,-1,1,-1,1,1,1,-1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,-1,1,-1,-1,1,1,-1,1,-1,1,-1,1}
+};
+
+static const int8_t maskD[32][32] __attribute__ ((aligned(32))) = {
+		{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
+		{1,1,-1,1,1,-1,-1,1,1,-1,-1,-1,1,1,1,-1,-1,1,-1,-1,-1,1,1,1,-1,-1,1,1,-1,-1,-1,1},
+		{1,1,1,1,-1,-1,1,-1,-1,1,-1,1,-1,-1,-1,-1,1,1,-1,1,1,1,-1,1,-1,-1,1,-1,1,-1,-1,1},
+		{1,1,-1,1,-1,1,-1,-1,-1,-1,1,-1,-1,-1,-1,1,-1,1,1,-1,-1,1,-1,1,1,1,1,-1,-1,1,1,1},
+		{1,1,-1,-1,1,-1,-1,-1,1,1,1,-1,-1,1,1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,-1,-1,-1,-1,1},
+		{1,1,1,-1,1,1,1,-1,1,-1,-1,1,-1,1,1,-1,-1,-1,-1,-1,-1,1,-1,-1,1,-1,-1,-1,1,1,1,1},
+		{1,1,-1,-1,-1,1,-1,1,-1,1,-1,-1,1,-1,-1,-1,1,-1,-1,1,1,1,1,-1,1,-1,-1,1,-1,1,1,1},
+		{1,1,1,-1,-1,-1,1,1,-1,-1,1,1,1,-1,-1,1,-1,-1,1,-1,-1,1,1,-1,-1,1,-1,1,1,-1,-1,1},
+		{1,-1,-1,1,1,1,-1,1,-1,-1,-1,1,-1,-1,1,-1,-1,1,1,1,1,-1,1,-1,-1,1,-1,-1,1,1,-1,1},
+		{1,-1,1,1,1,-1,1,1,-1,1,1,-1,-1,-1,1,1,1,1,-1,-1,-1,-1,1,-1,1,-1,-1,-1,-1,-1,1,1},
+		{1,-1,-1,1,-1,-1,-1,-1,1,-1,1,1,1,1,-1,1,-1,1,-1,1,1,-1,-1,-1,1,-1,-1,1,1,-1,1,1},
+		{1,-1,1,1,-1,1,1,-1,1,1,-1,-1,1,1,-1,-1,1,1,1,-1,-1,-1,-1,-1,-1,1,-1,1,-1,1,-1,1},
+		{1,-1,1,-1,1,-1,1,-1,-1,-1,-1,-1,1,-1,1,-1,-1,-1,1,1,1,-1,-1,1,1,1,1,1,-1,-1,1,1},
+		{1,-1,-1,-1,1,1,-1,-1,-1,1,1,1,1,-1,1,1,1,-1,-1,-1,-1,-1,-1,1,-1,-1,1,1,1,1,-1,1},
+		{1,-1,1,-1,-1,1,1,1,1,-1,1,-1,-1,1,-1,1,-1,-1,-1,1,1,-1,1,1,-1,-1,1,-1,-1,1,-1,1},
+		{1,-1,-1,-1,-1,-1,-1,1,1,1,-1,1,-1,1,-1,-1,1,-1,1,-1,-1,-1,1,1,1,1,1,-1,1,-1,1,1},
+		{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1,-1,-1,-1,-1,1,-1,1,1,1,1,-1,1},
+		{-1,-1,1,-1,-1,1,1,-1,-1,1,1,1,-1,-1,-1,1,-1,1,-1,-1,1,-1,-1,-1,-1,1,1,1,-1,-1,1,1},
+		{-1,-1,-1,-1,1,1,-1,1,1,-1,1,-1,1,1,1,1,1,1,-1,1,-1,-1,1,-1,-1,1,1,-1,1,-1,1,1},
+		{-1,-1,1,-1,1,-1,1,1,1,1,-1,1,1,1,1,-1,-1,1,1,-1,1,-1,1,-1,1,-1,1,-1,-1,1,-1,1},
+		{-1,-1,1,1,-1,1,1,1,-1,-1,-1,1,1,-1,-1,-1,1,-1,1,1,-1,-1,1,1,-1,-1,-1,-1,-1,-1,1,1},
+		{-1,-1,-1,1,-1,-1,-1,1,-1,1,1,-1,1,-1,-1,1,-1,-1,-1,-1,1,-1,1,1,1,1,-1,-1,1,1,-1,1},
+		{-1,-1,1,1,1,-1,1,-1,1,-1,1,1,-1,1,1,1,1,-1,-1,1,-1,-1,-1,1,1,1,-1,1,-1,1,-1,1},
+		{-1,-1,-1,1,1,1,-1,-1,1,1,-1,-1,-1,1,1,-1,-1,-1,1,-1,1,-1,-1,1,-1,-1,-1,1,1,-1,1,1},
+		{-1,1,1,-1,-1,-1,1,-1,1,1,1,-1,1,1,-1,1,-1,1,1,1,-1,1,-1,1,-1,-1,-1,-1,1,1,1,1},
+		{-1,1,-1,-1,-1,1,-1,-1,1,-1,-1,1,1,1,-1,-1,1,1,-1,-1,1,1,-1,1,1,1,-1,-1,-1,-1,-1,1},
+		{-1,1,1,-1,1,1,1,1,-1,1,-1,-1,-1,-1,1,-1,-1,1,-1,1,-1,1,1,1,1,1,-1,1,1,-1,-1,1},
+		{-1,1,-1,-1,1,-1,-1,1,-1,-1,1,1,-1,-1,1,1,1,1,1,-1,1,1,1,1,-1,-1,-1,1,-1,1,1,1},
+		{-1,1,-1,1,-1,1,-1,1,1,1,1,1,-1,1,-1,1,-1,-1,1,1,-1,1,1,-1,1,-1,1,1,-1,-1,-1,1},
+		{-1,1,1,1,-1,-1,1,1,1,-1,-1,-1,-1,1,-1,-1,1,-1,-1,-1,1,1,1,-1,-1,1,1,1,1,1,1,1},
+		{-1,1,-1,1,1,-1,-1,-1,-1,1,-1,1,1,-1,1,-1,-1,-1,-1,1,-1,1,-1,-1,-1,1,1,-1,-1,1,1,1,},
+		{-1,1,1,1,1,1,1,-1,-1,-1,1,-1,1,-1,1,1,1,-1,1,-1,1,1,-1,-1,1,-1,1,-1,1,-1,-1,1}
+};
+
+
+
+#endif
+
diff --git a/openair1/PHY/CODING/nr_polar_init.c b/openair1/PHY/CODING/nr_polar_init.c
index 93bcdecd6e..946657a905 100644
--- a/openair1/PHY/CODING/nr_polar_init.c
+++ b/openair1/PHY/CODING/nr_polar_init.c
@@ -42,9 +42,9 @@ static int intcmp(const void *p1,const void *p2) {
 }
 
 void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
-		   int8_t messageType,
-		   uint16_t messageLength,
-		   uint8_t aggregation_level)
+				   int8_t messageType,
+				   uint16_t messageLength,
+				   uint8_t aggregation_level)
 {
 	t_nrPolar_paramsPtr currentPtr = *polarParams;
 	uint16_t aggregation_prime = nr_polar_aggregation_prime(aggregation_level);
@@ -63,7 +63,8 @@ void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
 	if (newPolarInitNode != NULL) {
 
 		newPolarInitNode->idx = (messageType * messageLength * aggregation_prime);
-		newPolarInitNode->nextPtr = NULL;
+		newPolarInitNode->nextPtr = (t_nrPolar_params *)NULL;
+
 		//printf("newPolarInitNode->idx %d, (%d,%d,%d:%d)\n",newPolarInitNode->idx,messageType,messageLength,aggregation_prime,aggregation_level);
 
 		if (messageType == 0) { //PBCH
@@ -186,9 +187,7 @@ void nr_polar_init(t_nrPolar_paramsPtr *polarParams,
 	  currentPtr = currentPtr->nextPtr;
 	}
 	currentPtr->nextPtr= newPolarInitNode;
-	printf("Adding new polarParams entry to list index %d,%p\n",
-	       newPolarInitNode->idx,
-	       currentPtr->nextPtr);
+	printf("Adding new polarParams entry to list index %d,%p\n", newPolarInitNode->idx, currentPtr->nextPtr);
 
 	return;
 }
@@ -209,9 +208,9 @@ void nr_polar_print_polarParams(t_nrPolar_paramsPtr polarParams)
 }
 
 t_nrPolar_paramsPtr nr_polar_params (t_nrPolar_paramsPtr polarParams,
-				     int8_t messageType,
-				     uint16_t messageLength,
-				     uint8_t aggregation_level)
+									 int8_t messageType,
+									 uint16_t messageLength,
+									 uint8_t aggregation_level)
 {
 	t_nrPolar_paramsPtr currentPtr = NULL;