diff --git a/openair1/PHY/LTE_TRANSPORT/dci_tools.c b/openair1/PHY/LTE_TRANSPORT/dci_tools.c
index 0da47dbdfff85c86fa9ebc056f55a8c040e626c4..d044ea45d8eccbc4eb9130fe7605ccc0bd8a8292 100755
--- a/openair1/PHY/LTE_TRANSPORT/dci_tools.c
+++ b/openair1/PHY/LTE_TRANSPORT/dci_tools.c
@@ -44,6 +44,7 @@
 #include "PHY/vars.h"
 #endif
 #include "assertions.h"
+//#define DEBUG_HARQ
 
 //#define DEBUG_DCI
 
@@ -1525,7 +1526,9 @@ int generate_eNB_dlsch_params_from_dci(int frame,
       dlsch1_harq->status = ACTIVE;
       dlsch0_harq->codeword=0;
       dlsch1_harq->codeword=1;
+#ifdef DEBUG_HARQ
       printf("\n ENB: BOTH ACTIVE\n");
+#endif
     }
     else if (TB0_active && TB1_active && tbswap==1) {
       dlsch0=dlsch[0];
@@ -1564,7 +1567,9 @@ int generate_eNB_dlsch_params_from_dci(int frame,
       dlsch1_harq->codeword = 0;
       dlsch0=NULL;
       dlsch0_harq = NULL;
+#ifdef DEBUG_HARQ
       printf("\n ENB: TB0 is deactivated, retransmit TB1 transmit in TM6\n");
+#endif
     }
 
     if (dlsch0 != NULL){
@@ -2800,8 +2805,15 @@ int generate_eNB_dlsch_params_from_dci(int frame,
 #endif
 
   // compute DL power control parameters
+  if (dlsch0 != NULL){
   computeRhoA_eNB(pdsch_config_dedicated, dlsch[0],dlsch0_harq->dl_power_off, frame_parms->nb_antennas_tx_eNB);
   computeRhoB_eNB(pdsch_config_dedicated,&(frame_parms->pdsch_config_common),frame_parms->nb_antennas_tx_eNB,dlsch[0],dlsch0_harq->dl_power_off);
+}
+  if (dlsch1 != NULL){
+      computeRhoA_eNB(pdsch_config_dedicated, dlsch[1],dlsch1_harq->dl_power_off, frame_parms->nb_antennas_tx_eNB);
+  computeRhoB_eNB(pdsch_config_dedicated,&(frame_parms->pdsch_config_common),frame_parms->nb_antennas_tx_eNB,dlsch[1],dlsch1_harq->dl_power_off);
+  }
+
 
   return(0);
 }
@@ -4879,6 +4891,9 @@ int generate_ue_dlsch_params_from_dci(int frame,
     if ((rv2 == 1) && (mcs2 == 0)) {
       TB1_active=0;
     }
+#ifdef DEBUG_HARQ
+    printf("[DCI UE]: TB0 status %d , TB1 status %d\n", TB0_active, TB1_active);
+#endif
 
     //printf("RV TB0 = %d\n", rv1);
 
@@ -4898,7 +4913,9 @@ int generate_ue_dlsch_params_from_dci(int frame,
       dlsch1_harq->status = ACTIVE;
       dlsch0_harq->codeword=0;
       dlsch1_harq->codeword=1;
-      //printf("\n UE: BOTH ACTIVE\n");
+#ifdef DEBUG_HARQ
+      printf("[DCI UE]: BOTH ACTIVE\n");
+#endif
     }
     else if (TB0_active && TB1_active && tbswap==1) {
       dlsch0=dlsch[0];
@@ -4937,7 +4954,9 @@ int generate_ue_dlsch_params_from_dci(int frame,
       dlsch1_harq->codeword = 0;
       dlsch0=NULL;
       dlsch0_harq = NULL;
-      //printf("\n UE: TB0 is deactivated, retransmit TB1 transmit in TM6\n");
+#ifdef DEBUG_HARQ
+      printf("[DCI UE]: TB0 is deactivated, retransmit TB1 transmit in TM6\n");
+#endif
     }
 
 
@@ -4990,7 +5009,9 @@ int generate_ue_dlsch_params_from_dci(int frame,
         dlsch1_harq->rb_alloc_odd[1]= dlsch1_harq->rb_alloc_even[1];
         dlsch1_harq->rb_alloc_odd[2]= dlsch1_harq->rb_alloc_even[2];
         dlsch1_harq->rb_alloc_odd[3]= dlsch1_harq->rb_alloc_even[3];
-        dlsch1_harq->nb_rb = dlsch0_harq->nb_rb;
+        dlsch1_harq->nb_rb = conv_nprb(rah,
+                                       rballoc,
+                                       frame_parms->N_RB_DL);
       }
 
 
@@ -5010,6 +5031,9 @@ int generate_ue_dlsch_params_from_dci(int frame,
 
     if (dlsch1_harq != NULL)
       dlsch1_harq->Nl = 1;
+#ifdef DEBUG_HARQ
+    printf ("[DCI UE] tpmi = %d\n", tpmi);
+#endif
 
 
     if ((dlsch0 != NULL) && (dlsch1 != NULL)){  //two CW active
@@ -5112,7 +5136,10 @@ int generate_ue_dlsch_params_from_dci(int frame,
           break;
         }
     }
-
+#ifdef DEBUG_HARQ
+    printf("[DCI UE] harq1 MIMO mode = %d\n", dlsch1_harq->mimo_mode);
+#endif
+    //printf(" UE DCI harq0 MIMO mode = %d\n", dlsch0_harq->mimo_mode);
     if ((frame_parms->mode1_flag == 1) && (dlsch0_harq != NULL))
       dlsch0_harq->mimo_mode   = SISO;
 
@@ -5196,6 +5223,12 @@ int generate_ue_dlsch_params_from_dci(int frame,
 
           dlsch1->rnti = rnti;
     }
+#ifdef DEBUG_HARQ
+    if (dlsch0 != NULL)
+      printf("[DCI UE] dlsch0_harq status = %d, dlsch1_harq status = %d\n", dlsch0_harq->status, dlsch1_harq->status);
+    else
+      printf("[DCI UE] dlsch1_harq status = %d\n", dlsch1_harq->status);
+#endif
 
    break;
 
@@ -5869,11 +5902,19 @@ int generate_ue_dlsch_params_from_dci(int frame,
   }
 
 #endif
-  dlsch[0]->active=1;
+  //dlsch[0]->active=1;
 
   // compute DL power control parameters
-  computeRhoA_UE(pdsch_config_dedicated, dlsch[0],dlsch0_harq->dl_power_off, frame_parms->nb_antennas_tx_eNB);
-  computeRhoB_UE(pdsch_config_dedicated,&(frame_parms->pdsch_config_common),frame_parms->nb_antennas_tx_eNB,dlsch[0],dlsch0_harq->dl_power_off);
+  if (dlsch0_harq != NULL){
+    computeRhoA_UE(pdsch_config_dedicated, dlsch[0],dlsch0_harq->dl_power_off, frame_parms->nb_antennas_tx_eNB);
+    computeRhoB_UE(pdsch_config_dedicated,&(frame_parms->pdsch_config_common),frame_parms->nb_antennas_tx_eNB,dlsch[0],dlsch0_harq->dl_power_off);
+  }
+
+  if (dlsch1_harq != NULL) {
+    computeRhoA_UE(pdsch_config_dedicated, dlsch[1],dlsch1_harq->dl_power_off, frame_parms->nb_antennas_tx_eNB);
+    computeRhoB_UE(pdsch_config_dedicated,&(frame_parms->pdsch_config_common),frame_parms->nb_antennas_tx_eNB,dlsch[1],dlsch1_harq->dl_power_off);
+  }
+
 
   return(0);
 }
diff --git a/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c b/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c
old mode 100755
new mode 100644
index 59e988861b5bc2f4621d3969480894ab3312d23c..0b16c1953fbb6a2eb698d5a1090b6377a197689c
--- a/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c
+++ b/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c
@@ -37,8 +37,7 @@
  * \note
  * \warning
  */
-
-#include "PHY/defs.h"
+//#include "PHY/defs.h"
 #include "PHY/extern.h"
 #include "defs.h"
 #include "extern.h"
@@ -51,6 +50,8 @@
 #define NOCYGWIN_STATIC
 #endif
 
+//#define DEBUG_HARQ
+
 //#undef LOG_D
 //#define LOG_D LOG_I
 
@@ -68,9 +69,9 @@ uint8_t interf_unaw_shift1=0;
 uint8_t interf_unaw_shift=0;
 //inferference-free case
 unsigned char interf_unaw_shift_tm4_mcs[29]={5, 3, 4, 3, 3, 2, 1, 1, 2, 0, 1, 1, 1, 1, 0, 0,
-					     1, 1, 1, 1, 0, 2, 1, 0, 1, 0, 1, 0, 0} ;
+                                             1, 1, 1, 1, 0, 2, 1, 0, 1, 0, 1, 0, 0} ;
 unsigned char interf_unaw_shift_tm1_mcs[29]={5, 5, 4, 3, 3, 3, 2, 2, 4, 4, 2, 3, 3, 3, 1, 1,
-					     0, 1, 1, 2, 5, 4, 4, 6, 5, 1, 0, 5, 6} ; // mcs 21, 26, 28 seem to be errorneous
+                                             0, 1, 1, 2, 5, 4, 4, 6, 5, 1, 0, 5, 6} ; // mcs 21, 26, 28 seem to be errorneous
 
 /*
 //original values from sebastion + same hand tuning
@@ -139,12 +140,30 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     break;
 
   case PDSCH:
+
     lte_ue_pdsch_vars = &phy_vars_ue->lte_ue_pdsch_vars[eNB_id];
     dlsch_ue          = phy_vars_ue->dlsch_ue[eNB_id];
-    codeword_TB0      = dlsch_ue[0]->harq_processes[harq_pid]->codeword;
-    codeword_TB1      = dlsch_ue[1]->harq_processes[harq_pid]->codeword;
-    dlsch0_harq       = dlsch_ue[codeword_TB0]->harq_processes[harq_pid];
-    dlsch1_harq       = dlsch_ue[codeword_TB1]->harq_processes[harq_pid];
+    if ((dlsch_ue[0]->harq_processes[harq_pid]->status == ACTIVE) &&
+        (dlsch_ue[1]->harq_processes[harq_pid]->status == ACTIVE)){
+      codeword_TB0      = dlsch_ue[0]->harq_processes[harq_pid]->codeword;
+      codeword_TB1      = dlsch_ue[1]->harq_processes[harq_pid]->codeword;
+      dlsch0_harq       = dlsch_ue[codeword_TB0]->harq_processes[harq_pid];
+      dlsch1_harq       = dlsch_ue[codeword_TB1]->harq_processes[harq_pid];
+    }
+     else if ((dlsch_ue[0]->harq_processes[harq_pid]->status == ACTIVE) &&
+              (dlsch_ue[1]->harq_processes[harq_pid]->status != ACTIVE) ) {
+      codeword_TB0      = dlsch_ue[0]->harq_processes[harq_pid]->codeword;
+      dlsch0_harq       = dlsch_ue[0]->harq_processes[harq_pid];
+      dlsch1_harq       = NULL;
+      codeword_TB1      = -1;
+    }
+     else if ((dlsch_ue[0]->harq_processes[harq_pid]->status != ACTIVE) &&
+              (dlsch_ue[1]->harq_processes[harq_pid]->status == ACTIVE) ){
+      codeword_TB1      = dlsch_ue[1]->harq_processes[harq_pid]->codeword;
+      dlsch0_harq       = dlsch_ue[1]->harq_processes[harq_pid];
+      dlsch1_harq       = NULL;
+      codeword_TB0      = -1;
+    }
     break;
 
   default:
@@ -152,6 +171,10 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     return(-1);
     break;
   }
+#ifdef DEBUG_HARQ
+  printf("[DEMOD] MIMO mode = %d\n", dlsch0_harq->mimo_mode);
+  printf("[DEMOD] cw for TB0 = %d, cw for TB1 = %d\n", codeword_TB0, codeword_TB1);
+#endif
 
   DevAssert(dlsch0_harq);
   round = dlsch0_harq->round;
@@ -216,11 +239,11 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
                                    subframe,
                                    phy_vars_ue->high_speed_flag,
                                    frame_parms,
-				                           dlsch0_harq->mimo_mode);
+                                                           dlsch0_harq->mimo_mode);
 //#ifdef DEBUG_DLSCH_MOD
     /*   printf("dlsch: using pmi %lx, rb_alloc %x, pmi_ext ",pmi2hex_2Ar1(dlsch0_harq->pmi_alloc),*rballoc);
        for (rb=0;rb<nb_rb;rb++)
-	  printf("%d",lte_ue_pdsch_vars[eNB_id]->pmi_ext[rb]);
+          printf("%d",lte_ue_pdsch_vars[eNB_id]->pmi_ext[rb]);
        printf("\n");*/
 //#endif
 
@@ -237,7 +260,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
                                        subframe,
                                        phy_vars_ue->high_speed_flag,
                                        frame_parms,
-				                               dlsch0_harq->mimo_mode);
+                                                               dlsch0_harq->mimo_mode);
      else
        nb_rb = dlsch_extract_rbs_dual(lte_ue_common_vars->rxdataF,
                                        lte_ue_common_vars->dl_ch_estimates[eNB_id],
@@ -250,7 +273,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
                                        subframe,
                                        phy_vars_ue->high_speed_flag,
                                        frame_parms,
-				                               dlsch0_harq->mimo_mode);
+                                                               dlsch0_harq->mimo_mode);
     }
   } // if n_tx>1
   else {
@@ -311,14 +334,15 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
 
   if (dlsch0_harq->mimo_mode<LARGE_CDD) {// SISO or ALAMOUTI
 
+
      dlsch_scale_channel(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-			  frame_parms,
-			  dlsch_ue,
-			  symbol,
-			  nb_rb);
+                          frame_parms,
+                          dlsch_ue,
+                          symbol,
+                          nb_rb);
 
       if (first_symbol_flag==1) {
-	dlsch_channel_level(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+        dlsch_channel_level(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                         frame_parms,
                         avg,
                         symbol,
@@ -339,7 +363,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
       }
 
 
-    	dlsch_channel_compensation(lte_ue_pdsch_vars[eNB_id]->rxdataF_ext,
+        dlsch_channel_compensation(lte_ue_pdsch_vars[eNB_id]->rxdataF_ext,
                                lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                                lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
                                lte_ue_pdsch_vars[eNB_id]->dl_ch_magb0,
@@ -359,7 +383,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     if ((rx_type==rx_IC_single_stream) &&
         (eNB_id_i<phy_vars_ue->n_connected_eNB)) {
 
-	 dlsch_channel_compensation(lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext,
+         dlsch_channel_compensation(lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext,
                                  lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
                                  lte_ue_pdsch_vars[eNB_id_i]->dl_ch_mag0,
                                  lte_ue_pdsch_vars[eNB_id_i]->dl_ch_magb0,
@@ -399,23 +423,23 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     if (frame_parms->nb_antennas_tx_eNB == 2) {
 
 
-	 // scaling interfering channel (following for TM56)
-	dlsch_scale_channel(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-			    frame_parms,
-			    dlsch_ue,
-			    symbol,
-			    nb_rb);
+         // scaling interfering channel (following for TM56)
+        dlsch_scale_channel(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+                            frame_parms,
+                            dlsch_ue,
+                            symbol,
+                            nb_rb);
 
 
       if (first_symbol_flag==1) {
         // effective channel of desired user is always stronger than interfering eff. channel
         dlsch_channel_level_TM34(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                                  frame_parms,
-				 lte_ue_pdsch_vars[eNB_id]->pmi_ext,
+                                 lte_ue_pdsch_vars[eNB_id]->pmi_ext,
                                  avg_0,
-				 avg_1,
-				 symbol,
-				 nb_rb,
+                                 avg_1,
+                                 symbol,
+                                 nb_rb,
                                  dlsch0_harq->mimo_mode);
 
 
@@ -423,27 +447,27 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
  //  write_output("dlsch0_r0_aver_chan_1.m","dl_aver_ch1_r0_0",&avg_1[0],1,1,2);
 
 
-	if (rx_type>rx_standard) {
-	// Shifts are needed to avoid tails in SNR/BLER curves.
-	// LUT will be introduced with mcs-dependent shift
-	avg_0[0] = (log2_approx(avg_0[0])/2) -13 + interf_unaw_shift;
-	avg_1[0] = (log2_approx(avg_1[0])/2) -13 + interf_unaw_shift;
-	lte_ue_pdsch_vars[eNB_id]->log2_maxh0 = cmax(avg_0[0],0);
-	lte_ue_pdsch_vars[eNB_id]->log2_maxh1 = cmax(avg_1[0],0);
-
-	//printf("TM4 I-A log2_maxh0 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh0);
-	//printf("TM4 I-A log2_maxh1 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh1);
-
-	 }
-	else {
-	// Shifts are needed to avoid tails in SNR/BLER curves.
-	// LUT will be introduced with mcs-dependent shift
-	avg_0[0] = (log2_approx(avg_0[0])/2) - 13 + interf_unaw_shift;
-	avg_1[0] = (log2_approx(avg_1[0])/2) - 13 + interf_unaw_shift;
-	lte_ue_pdsch_vars[eNB_id]->log2_maxh0 = cmax(avg_0[0],0);
-	lte_ue_pdsch_vars[eNB_id]->log2_maxh1 = cmax(avg_1[0],0);
-	//printf("TM4 I-UA log2_maxh0 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh0);
-	//printf("TM4 I-UA log2_maxh1 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh1);
+        if (rx_type>rx_standard) {
+        // Shifts are needed to avoid tails in SNR/BLER curves.
+        // LUT will be introduced with mcs-dependent shift
+        avg_0[0] = (log2_approx(avg_0[0])/2) -13 + interf_unaw_shift;
+        avg_1[0] = (log2_approx(avg_1[0])/2) -13 + interf_unaw_shift;
+        lte_ue_pdsch_vars[eNB_id]->log2_maxh0 = cmax(avg_0[0],0);
+        lte_ue_pdsch_vars[eNB_id]->log2_maxh1 = cmax(avg_1[0],0);
+
+        //printf("TM4 I-A log2_maxh0 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh0);
+        //printf("TM4 I-A log2_maxh1 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh1);
+
+         }
+        else {
+        // Shifts are needed to avoid tails in SNR/BLER curves.
+        // LUT will be introduced with mcs-dependent shift
+        avg_0[0] = (log2_approx(avg_0[0])/2) - 13 + interf_unaw_shift;
+        avg_1[0] = (log2_approx(avg_1[0])/2) - 13 + interf_unaw_shift;
+        lte_ue_pdsch_vars[eNB_id]->log2_maxh0 = cmax(avg_0[0],0);
+        lte_ue_pdsch_vars[eNB_id]->log2_maxh1 = cmax(avg_1[0],0);
+        //printf("TM4 I-UA log2_maxh0 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh0);
+        //printf("TM4 I-UA log2_maxh1 = %d\n", lte_ue_pdsch_vars[eNB_id]->log2_maxh1);
         }
       }
 
@@ -459,7 +483,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
                                      dlsch0_harq->mimo_mode,
                                      nb_rb,
                                      lte_ue_pdsch_vars[eNB_id]->log2_maxh0,
-				     lte_ue_pdsch_vars[eNB_id]->log2_maxh1);
+                                     lte_ue_pdsch_vars[eNB_id]->log2_maxh1);
 
   /*   if (symbol == 5) {
 
@@ -469,11 +493,11 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
      write_output("rxF_comp_d11.m","rxF_c_d11",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[harq_pid][round][1][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be QAM
 
 
-	} */
+        } */
 
       // compute correlation between signal and interference channels (rho12 and rho21)
 
-	dlsch_dual_stream_correlation(frame_parms, // this is doing h11'*h12 and h21'*h22
+        dlsch_dual_stream_correlation(frame_parms, // this is doing h11'*h12 and h21'*h22
                                     symbol,
                                     nb_rb,
                                     lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
@@ -481,17 +505,17 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
                                     lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
                                     lte_ue_pdsch_vars[eNB_id]->log2_maxh0);
 
-	//printf("rho stream1 =%d\n", &lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round] );
+        //printf("rho stream1 =%d\n", &lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round] );
 
       //to be optimized (just take complex conjugate)
 
       dlsch_dual_stream_correlation(frame_parms, // this is doing h12'*h11 and h22'*h21
                                     symbol,
                                     nb_rb,
-				    &(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext[2]),
+                                    &(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext[2]),
                                     lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-				    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-				    lte_ue_pdsch_vars[eNB_id]->log2_maxh1);
+                                    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
+                                    lte_ue_pdsch_vars[eNB_id]->log2_maxh1);
     //  printf("rho stream2 =%d\n",&lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext );
       //printf("TM3 log2_maxh : %d\n",lte_ue_pdsch_vars[eNB_id]->log2_maxh);
 
@@ -503,7 +527,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
      write_output("rho2_1.m","rho2_1",&lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext[1][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be QAM
 
 
-	} */
+        } */
 
    }
       else {
@@ -534,11 +558,11 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
 
         // effective channel of desired user is always stronger than interfering eff. channel
        dlsch_channel_level_TM56(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-				frame_parms,
-				lte_ue_pdsch_vars[eNB_id]->pmi_ext,
-				avg,
-				symbol,
-				nb_rb);
+                                frame_parms,
+                                lte_ue_pdsch_vars[eNB_id]->pmi_ext,
+                                avg,
+                                symbol,
+                                nb_rb);
 
         //    LOG_D(PHY,"llr_offset = %d\n",offset_mumimo_llr_drange[dlsch0_harq->mcs][(i_mod>>1)-1]);
         avg[0] = log2_approx(avg[0]) - 13 + offset_mumimo_llr_drange[dlsch0_harq->mcs][(i_mod>>1)-1];
@@ -623,13 +647,14 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     else if (dlsch0_harq->dl_power_off==1)  {
 
         dlsch_scale_channel(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-			  frame_parms,
-			  dlsch_ue,
-			  symbol,
-			  nb_rb);
+                          frame_parms,
+                          dlsch_ue,
+                          symbol,
+                          nb_rb);
 
       if (first_symbol_flag==1) {
-	      dlsch_channel_level(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+
+        dlsch_channel_level(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                             frame_parms,
                             avg,
                             symbol,
@@ -638,19 +663,19 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     LOG_D(PHY,"[DLSCH] avg[0] %d\n",avg[0]);
 #endif
 
-    avgs = 0;
+        avgs = 0;
 
-    for (aatx=0;aatx<frame_parms->nb_antennas_tx_eNB;aatx++)
-      for (aarx=0;aarx<frame_parms->nb_antennas_rx;aarx++)
-        avgs = cmax(avgs,avg[(aatx<<1)+aarx]);
-    //  avgs = cmax(avgs,avg[(aarx<<1)+aatx]);
+        for (aatx=0;aatx<frame_parms->nb_antennas_tx_eNB;aatx++)
+          for (aarx=0;aarx<frame_parms->nb_antennas_rx;aarx++)
+            avgs = cmax(avgs,avg[(aatx<<1)+aarx]);
+        //  avgs = cmax(avgs,avg[(aarx<<1)+aatx]);
 
-   lte_ue_pdsch_vars[eNB_id]->log2_maxh = (log2_approx(avgs)/2) + interf_unaw_shift_tm1_mcs[dlsch0_harq->mcs];
+        lte_ue_pdsch_vars[eNB_id]->log2_maxh = (log2_approx(avgs)/2) + 1;
+        lte_ue_pdsch_vars[eNB_id]->log2_maxh++;
 
       }
 
 
-
       dlsch_channel_compensation_TM56(lte_ue_pdsch_vars[eNB_id]->rxdataF_ext,
                                       lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
                                       lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
@@ -676,20 +701,20 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
          (dlsch0_harq->mimo_mode <=DUALSTREAM_PUSCH_PRECODING))){  // TM3 or TM4
       if (frame_parms->nb_antennas_tx_eNB == 2) {
 
-	dlsch_detection_mrc_TM34(frame_parms,
+        dlsch_detection_mrc_TM34(frame_parms,
                                  lte_ue_pdsch_vars[eNB_id],
-				 harq_pid,
+                                 harq_pid,
                                  dlsch0_harq->round,
-				 symbol,
-				 nb_rb,
-				 1);
+                                 symbol,
+                                 nb_rb,
+                                 1);
 
 
     /*   if (symbol == 5) {
 
      write_output("rho0_mrc.m","rho0_0",&lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round][0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);// should be QAM
      write_output("rho2_mrc.m","rho2_0",&lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be almost 0
-    	} */
+        } */
 
 
       }
@@ -748,7 +773,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
 
   switch (dlsch0_harq->Qm) {
   case 2 :
-    if (rx_type==rx_standard) {
+    if ((rx_type==rx_standard) || (codeword_TB0 = 1)) {
         dlsch_qpsk_llr(frame_parms,
                        lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
                        lte_ue_pdsch_vars[eNB_id]->llr[0],
@@ -824,7 +849,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
       }
     break;
   case 4 :
-    if (rx_type==rx_standard) {
+    if ((rx_type==rx_standard ) || (codeword_TB0 = 1) ) {
       dlsch_16qam_llr(frame_parms,
                       lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
                       lte_ue_pdsch_vars[eNB_id]->llr[0],
@@ -833,7 +858,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
                       adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,4,subframe,symbol),
                       lte_ue_pdsch_vars[eNB_id]->llr128);
     }
-    else if (rx_type >= rx_IC_single_stream) {
+    else if ((rx_type >= rx_IC_single_stream) && (codeword_TB0 != -1))  {
       if (dlsch1_harq->Qm == 2) {
         dlsch_16qam_qpsk_llr(frame_parms,
                              lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
@@ -857,57 +882,57 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
         }
       }
       else if (dlsch1_harq->Qm == 4) {
-	dlsch_16qam_16qam_llr(frame_parms,
-			      lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			      rxdataF_comp_ptr,//i
-			      lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-			      dl_ch_mag_ptr,//i
-			      lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
-			      lte_ue_pdsch_vars[eNB_id]->llr[0],
-			      symbol,first_symbol_flag,nb_rb,
-			      adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,4,subframe,symbol),
-			      lte_ue_pdsch_vars[eNB_id]->llr128);
-	if (rx_type==rx_IC_dual_stream) {
-	  dlsch_16qam_16qam_llr(frame_parms,
-				rxdataF_comp_ptr,
-				lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i
-				dl_ch_mag_ptr,
-				lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,//i
-				lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-				lte_ue_pdsch_vars[eNB_id]->llr[1],
-				symbol,first_symbol_flag,nb_rb,
-				adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,4,subframe,symbol),
-				lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
-	}
+        dlsch_16qam_16qam_llr(frame_parms,
+                              lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                              rxdataF_comp_ptr,//i
+                              lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
+                              dl_ch_mag_ptr,//i
+                              lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
+                              lte_ue_pdsch_vars[eNB_id]->llr[0],
+                              symbol,first_symbol_flag,nb_rb,
+                              adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,4,subframe,symbol),
+                              lte_ue_pdsch_vars[eNB_id]->llr128);
+        if (rx_type==rx_IC_dual_stream) {
+          dlsch_16qam_16qam_llr(frame_parms,
+                                rxdataF_comp_ptr,
+                                lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i
+                                dl_ch_mag_ptr,
+                                lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,//i
+                                lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
+                                lte_ue_pdsch_vars[eNB_id]->llr[1],
+                                symbol,first_symbol_flag,nb_rb,
+                                adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,4,subframe,symbol),
+                                lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
+        }
       }
       else {
-	dlsch_16qam_64qam_llr(frame_parms,
-			      lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			      rxdataF_comp_ptr,//i
-			      lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-			      dl_ch_mag_ptr,//i
-			      lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
-			      lte_ue_pdsch_vars[eNB_id]->llr[0],
-			      symbol,first_symbol_flag,nb_rb,
-			      adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,4,subframe,symbol),
-			      lte_ue_pdsch_vars[eNB_id]->llr128);
-	if (rx_type==rx_IC_dual_stream) {
-	  dlsch_64qam_16qam_llr(frame_parms,
-				rxdataF_comp_ptr,
-				lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-				dl_ch_mag_ptr,
-				lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-				lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-				lte_ue_pdsch_vars[eNB_id]->llr[1],
-				symbol,first_symbol_flag,nb_rb,
-				adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,6,subframe,symbol),
-				lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
-	}
+        dlsch_16qam_64qam_llr(frame_parms,
+                              lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                              rxdataF_comp_ptr,//i
+                              lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
+                              dl_ch_mag_ptr,//i
+                              lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
+                              lte_ue_pdsch_vars[eNB_id]->llr[0],
+                              symbol,first_symbol_flag,nb_rb,
+                              adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,4,subframe,symbol),
+                              lte_ue_pdsch_vars[eNB_id]->llr128);
+        if (rx_type==rx_IC_dual_stream) {
+          dlsch_64qam_16qam_llr(frame_parms,
+                                rxdataF_comp_ptr,
+                                lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                                dl_ch_mag_ptr,
+                                lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
+                                lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
+                                lte_ue_pdsch_vars[eNB_id]->llr[1],
+                                symbol,first_symbol_flag,nb_rb,
+                                adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,6,subframe,symbol),
+                                lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
+        }
       }
     }
     break;
   case 6 :
-    if (rx_type==rx_standard) {
+    if ((rx_type==rx_standard) || (codeword_TB0 == -1))  {
       dlsch_64qam_llr(frame_parms,
                       lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
                       lte_ue_pdsch_vars[eNB_id]->llr[0],
@@ -917,76 +942,76 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
                       adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,subframe,symbol),
                       lte_ue_pdsch_vars[eNB_id]->llr128);
     }
-    else if (rx_type >= rx_IC_single_stream) {
+    else if ((rx_type >= rx_IC_single_stream) && (codeword_TB0 != -1)){
       if (dlsch1_harq->Qm == 2) {
-	dlsch_64qam_qpsk_llr(frame_parms,
-			     lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			     rxdataF_comp_ptr,//i
-			     lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-			     lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
-			     lte_ue_pdsch_vars[eNB_id]->llr[0],
-			     symbol,first_symbol_flag,nb_rb,
-			     adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,subframe,symbol),
-			     lte_ue_pdsch_vars[eNB_id]->llr128);
-	if (rx_type==rx_IC_dual_stream) {
-	  dlsch_qpsk_64qam_llr(frame_parms,
-			       rxdataF_comp_ptr,
-			       lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i
-			       lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-			       lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-			       lte_ue_pdsch_vars[eNB_id]->llr[1],
-			       symbol,first_symbol_flag,nb_rb,
-			       adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,2,subframe,symbol),
-			       lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
-	}
+        dlsch_64qam_qpsk_llr(frame_parms,
+                             lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                             rxdataF_comp_ptr,//i
+                             lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
+                             lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
+                             lte_ue_pdsch_vars[eNB_id]->llr[0],
+                             symbol,first_symbol_flag,nb_rb,
+                             adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,subframe,symbol),
+                             lte_ue_pdsch_vars[eNB_id]->llr128);
+        if (rx_type==rx_IC_dual_stream) {
+          dlsch_qpsk_64qam_llr(frame_parms,
+                               rxdataF_comp_ptr,
+                               lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i
+                               lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
+                               lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
+                               lte_ue_pdsch_vars[eNB_id]->llr[1],
+                               symbol,first_symbol_flag,nb_rb,
+                               adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,2,subframe,symbol),
+                               lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
+        }
       }
       else if (dlsch1_harq->Qm == 4) {
-	dlsch_64qam_16qam_llr(frame_parms,
-			      lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			      rxdataF_comp_ptr,//i
-			      lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-			      dl_ch_mag_ptr,//i
-			      lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
-			      lte_ue_pdsch_vars[eNB_id]->llr[0],
-			      symbol,first_symbol_flag,nb_rb,
-			      adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,subframe,symbol),
-			      lte_ue_pdsch_vars[eNB_id]->llr128);
-	if (rx_type==rx_IC_dual_stream) {
-	  dlsch_16qam_64qam_llr(frame_parms,
-				rxdataF_comp_ptr,
-				lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i
-				dl_ch_mag_ptr,
-				lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,//i
-				lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-				lte_ue_pdsch_vars[eNB_id]->llr[1],
-				symbol,first_symbol_flag,nb_rb,
-				adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,4,subframe,symbol),
-				lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
-	}
+        dlsch_64qam_16qam_llr(frame_parms,
+                              lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                              rxdataF_comp_ptr,//i
+                              lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
+                              dl_ch_mag_ptr,//i
+                              lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
+                              lte_ue_pdsch_vars[eNB_id]->llr[0],
+                              symbol,first_symbol_flag,nb_rb,
+                              adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,subframe,symbol),
+                              lte_ue_pdsch_vars[eNB_id]->llr128);
+        if (rx_type==rx_IC_dual_stream) {
+          dlsch_16qam_64qam_llr(frame_parms,
+                                rxdataF_comp_ptr,
+                                lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i
+                                dl_ch_mag_ptr,
+                                lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,//i
+                                lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
+                                lte_ue_pdsch_vars[eNB_id]->llr[1],
+                                symbol,first_symbol_flag,nb_rb,
+                                adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,4,subframe,symbol),
+                                lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
+        }
       }
       else {
-	dlsch_64qam_64qam_llr(frame_parms,
-			      lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			      rxdataF_comp_ptr,//i
-			      lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-			      dl_ch_mag_ptr,//i
-			      lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
-			      lte_ue_pdsch_vars[eNB_id]->llr[0],
-			      symbol,first_symbol_flag,nb_rb,
-			      adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,subframe,symbol),
-			      lte_ue_pdsch_vars[eNB_id]->llr128);
-	if (rx_type==rx_IC_dual_stream) {
-	  dlsch_64qam_64qam_llr(frame_parms,
-				rxdataF_comp_ptr,
-				lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i
-				dl_ch_mag_ptr,
-				lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,//i
-				lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
-				lte_ue_pdsch_vars[eNB_id]->llr[1],
-				symbol,first_symbol_flag,nb_rb,
-				adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,6,subframe,symbol),
-				lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
-	}
+        dlsch_64qam_64qam_llr(frame_parms,
+                              lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                              rxdataF_comp_ptr,//i
+                              lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
+                              dl_ch_mag_ptr,//i
+                              lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
+                              lte_ue_pdsch_vars[eNB_id]->llr[0],
+                              symbol,first_symbol_flag,nb_rb,
+                              adjust_G2(frame_parms,dlsch0_harq->rb_alloc_even,6,subframe,symbol),
+                              lte_ue_pdsch_vars[eNB_id]->llr128);
+        if (rx_type==rx_IC_dual_stream) {
+          dlsch_64qam_64qam_llr(frame_parms,
+                                rxdataF_comp_ptr,
+                                lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i
+                                dl_ch_mag_ptr,
+                                lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,//i
+                                lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
+                                lte_ue_pdsch_vars[eNB_id]->llr[1],
+                                symbol,first_symbol_flag,nb_rb,
+                                adjust_G2(frame_parms,dlsch1_harq->rb_alloc_even,6,subframe,symbol),
+                                lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
+        }
       }
 
     }
@@ -1689,7 +1714,7 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
     Nre = (pilots==0) ? 12 : 8;
 
     precoded_signal_strength += ((signal_energy_nodc(&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*Nre],
-						     (nb_rb*Nre))) - (phy_measurements->n0_power[aarx]));
+                                                     (nb_rb*Nre))) - (phy_measurements->n0_power[aarx]));
   } // rx_antennas
 
   phy_measurements->precoded_cqi_dB[eNB_id][0] = dB_fixed2(precoded_signal_strength,phy_measurements->n0_power_tot);
@@ -1754,51 +1779,51 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
       prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128b[1],&dl_ch1_128b[1]);
 
       if (pilots==0) {
-	prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128b[2],&dl_ch1_128b[2]);
+        prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128b[2],&dl_ch1_128b[2]);
       }
 
       if (mod_order>2) {
-	// get channel amplitude if not QPSK
-	mmtmpD0 = vmull_s16(dl_ch0_128[0], dl_ch0_128[0]);
-	// mmtmpD0 = [ch0*ch0,ch1*ch1,ch2*ch2,ch3*ch3];
-	mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
-	// mmtmpD0 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3]>>output_shift128 on 32-bits
-	mmtmpD1 = vmull_s16(dl_ch0_128[1], dl_ch0_128[1]);
-	mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
-	mmtmpD2 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	// mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits
-	mmtmpD0 = vmull_s16(dl_ch0_128[2], dl_ch0_128[2]);
-	mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
-	mmtmpD1 = vmull_s16(dl_ch0_128[3], dl_ch0_128[3]);
-	mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
-	mmtmpD3 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	if (pilots==0) {
-	  mmtmpD0 = vmull_s16(dl_ch0_128[4], dl_ch0_128[4]);
-	  mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
-	  mmtmpD1 = vmull_s16(dl_ch0_128[5], dl_ch0_128[5]);
-	  mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
-	  mmtmpD4 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-
-
-	}
-
-	dl_ch_mag128b[0] = vqdmulhq_s16(mmtmpD2,QAM_amp128b);
-	dl_ch_mag128b[1] = vqdmulhq_s16(mmtmpD3,QAM_amp128b);
-	dl_ch_mag128[0] = vqdmulhq_s16(mmtmpD2,QAM_amp128);
-	dl_ch_mag128[1] = vqdmulhq_s16(mmtmpD3,QAM_amp128);
-
-
-	if (pilots==0) {
-	  dl_ch_mag128b[2] = vqdmulhq_s16(mmtmpD4,QAM_amp128b);
-	  dl_ch_mag128[2]  = vqdmulhq_s16(mmtmpD4,QAM_amp128);
-	}
+        // get channel amplitude if not QPSK
+        mmtmpD0 = vmull_s16(dl_ch0_128[0], dl_ch0_128[0]);
+        // mmtmpD0 = [ch0*ch0,ch1*ch1,ch2*ch2,ch3*ch3];
+        mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
+        // mmtmpD0 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3]>>output_shift128 on 32-bits
+        mmtmpD1 = vmull_s16(dl_ch0_128[1], dl_ch0_128[1]);
+        mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
+        mmtmpD2 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
+        // mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits
+        mmtmpD0 = vmull_s16(dl_ch0_128[2], dl_ch0_128[2]);
+        mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
+        mmtmpD1 = vmull_s16(dl_ch0_128[3], dl_ch0_128[3]);
+        mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
+        mmtmpD3 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
+        if (pilots==0) {
+          mmtmpD0 = vmull_s16(dl_ch0_128[4], dl_ch0_128[4]);
+          mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
+          mmtmpD1 = vmull_s16(dl_ch0_128[5], dl_ch0_128[5]);
+          mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
+          mmtmpD4 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
+
+
+        }
+
+        dl_ch_mag128b[0] = vqdmulhq_s16(mmtmpD2,QAM_amp128b);
+        dl_ch_mag128b[1] = vqdmulhq_s16(mmtmpD3,QAM_amp128b);
+        dl_ch_mag128[0] = vqdmulhq_s16(mmtmpD2,QAM_amp128);
+        dl_ch_mag128[1] = vqdmulhq_s16(mmtmpD3,QAM_amp128);
+
+
+        if (pilots==0) {
+          dl_ch_mag128b[2] = vqdmulhq_s16(mmtmpD4,QAM_amp128b);
+          dl_ch_mag128[2]  = vqdmulhq_s16(mmtmpD4,QAM_amp128);
+        }
       }
       mmtmpD0 = vmull_s16(dl_ch0_128[0], rxdataF128[0]);
       //mmtmpD0 = [Re(ch[0])Re(rx[0]) Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1]) Im(ch[1])Im(ch[1])]
       mmtmpD1 = vmull_s16(dl_ch0_128[1], rxdataF128[1]);
       //mmtmpD1 = [Re(ch[2])Re(rx[2]) Im(ch[2])Im(ch[2]) Re(ch[3])Re(rx[3]) Im(ch[3])Im(ch[3])]
       mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
-			     vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
+                             vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
       //mmtmpD0 = [Re(ch[0])Re(rx[0])+Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1])+Im(ch[1])Im(ch[1]) Re(ch[2])Re(rx[2])+Im(ch[2])Im(ch[2]) Re(ch[3])Re(rx[3])+Im(ch[3])Im(ch[3])]
 
       mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[0],*(int16x4_t*)conj)), rxdataF128[0]);
@@ -1806,7 +1831,7 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
       mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[1],*(int16x4_t*)conj)), rxdataF128[1]);
       //mmtmpD0 = [-Im(ch[2])Re(rx[2]) Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3]) Re(ch[3])Im(rx[3])]
       mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
-			     vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
+                             vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
       //mmtmpD1 = [-Im(ch[0])Re(rx[0])+Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1])+Re(ch[1])Im(rx[1]) -Im(ch[2])Re(rx[2])+Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3])+Re(ch[3])Im(rx[3])]
 
       mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
@@ -1816,48 +1841,48 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
       mmtmpD0 = vmull_s16(dl_ch0_128[2], rxdataF128[2]);
       mmtmpD1 = vmull_s16(dl_ch0_128[3], rxdataF128[3]);
       mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
-			     vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
+                             vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
 
       mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[2],*(int16x4_t*)conj)), rxdataF128[2]);
       mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[3],*(int16x4_t*)conj)), rxdataF128[3]);
       mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
-			     vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
+                             vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
 
       mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
       mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
       rxdataF_comp128[1] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
 
       if (pilots==0) {
-	mmtmpD0 = vmull_s16(dl_ch0_128[4], rxdataF128[4]);
-	mmtmpD1 = vmull_s16(dl_ch0_128[5], rxdataF128[5]);
-	mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
-			       vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
+        mmtmpD0 = vmull_s16(dl_ch0_128[4], rxdataF128[4]);
+        mmtmpD1 = vmull_s16(dl_ch0_128[5], rxdataF128[5]);
+        mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
+                               vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
 
-	mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[4],*(int16x4_t*)conj)), rxdataF128[4]);
-	mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[5],*(int16x4_t*)conj)), rxdataF128[5]);
-	mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
-			       vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
+        mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[4],*(int16x4_t*)conj)), rxdataF128[4]);
+        mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[5],*(int16x4_t*)conj)), rxdataF128[5]);
+        mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
+                               vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
 
 
-	mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
-	mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
-	rxdataF_comp128[2] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
+        mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
+        mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
+        rxdataF_comp128[2] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
 
 
-	dl_ch0_128+=6;
-	dl_ch1_128+=6;
-	dl_ch_mag128+=3;
-	dl_ch_mag128b+=3;
-	rxdataF128+=6;
-	rxdataF_comp128+=3;
+        dl_ch0_128+=6;
+        dl_ch1_128+=6;
+        dl_ch_mag128+=3;
+        dl_ch_mag128b+=3;
+        rxdataF128+=6;
+        rxdataF_comp128+=3;
 
       } else { // we have a smaller PDSCH in symbols with pilots so skip last group of 4 REs and increment less
-	dl_ch0_128+=4;
-	dl_ch1_128+=4;
-	dl_ch_mag128+=2;
-	dl_ch_mag128b+=2;
-	rxdataF128+=4;
-	rxdataF_comp128+=2;
+        dl_ch0_128+=4;
+        dl_ch1_128+=4;
+        dl_ch_mag128+=2;
+        dl_ch_mag128b+=2;
+        rxdataF128+=4;
+        rxdataF_comp128+=2;
       }
     }
 
@@ -1865,7 +1890,7 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
 
 
     precoded_signal_strength += ((signal_energy_nodc(&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*Nre],
-						     (nb_rb*Nre))) - (phy_measurements->n0_power[aarx]));
+                                                     (nb_rb*Nre))) - (phy_measurements->n0_power[aarx]));
     // rx_antennas
   }
   phy_measurements->precoded_cqi_dB[eNB_id][0] = dB_fixed2(precoded_signal_strength,phy_measurements->n0_power_tot);
@@ -1890,7 +1915,7 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
                                     MIMO_mode_t mimo_mode,
                                     unsigned short nb_rb,
                                     unsigned char output_shift0,
-				    unsigned char output_shift1) {
+                                    unsigned char output_shift1) {
 
 #if defined(__x86_64__) || defined(__i386__)
 
@@ -1943,7 +1968,7 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
       output_shift=output_shift0;
     }
       else {
-	output_shift=output_shift1;
+        output_shift=output_shift1;
       } */
 
      // printf("antenna %d\n", aarx);
@@ -2384,79 +2409,79 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
 
 
       if (mod_order0>2) {
-	// get channel amplitude if not QPSK
-	mmtmpD0 = vmull_s16(dl_ch0_128[0], dl_ch0_128[0]);
-	// mmtmpD0 = [ch0*ch0,ch1*ch1,ch2*ch2,ch3*ch3];
-	mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
-	// mmtmpD0 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3]>>output_shift128 on 32-bits
-	mmtmpD1 = vmull_s16(dl_ch0_128[1], dl_ch0_128[1]);
-	mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
-	mmtmpD2 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	// mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits
-	mmtmpD0 = vmull_s16(dl_ch0_128[2], dl_ch0_128[2]);
-	mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
-	mmtmpD1 = vmull_s16(dl_ch0_128[3], dl_ch0_128[3]);
-	mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
-	mmtmpD3 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-
-	if (pilots==0) {
-	  mmtmpD0 = vmull_s16(dl_ch0_128[4], dl_ch0_128[4]);
-	  mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
-	  mmtmpD1 = vmull_s16(dl_ch0_128[5], dl_ch0_128[5]);
-	  mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
-	  mmtmpD4 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-
-
-	}
-
-	dl_ch_mag0_128b[0] = vqdmulhq_s16(mmtmpD2,QAM_amp0_128b);
-	dl_ch_mag0_128b[1] = vqdmulhq_s16(mmtmpD3,QAM_amp0_128b);
-	dl_ch_mag0_128[0] = vqdmulhq_s16(mmtmpD2,QAM_amp0_128);
-	dl_ch_mag0_128[1] = vqdmulhq_s16(mmtmpD3,QAM_amp0_128);
-
-
-	if (pilots==0) {
-	  dl_ch_mag0_128b[2] = vqdmulhq_s16(mmtmpD4,QAM_amp0_128b);
-	  dl_ch_mag0_128[2]  = vqdmulhq_s16(mmtmpD4,QAM_amp0_128);
-	}
+        // get channel amplitude if not QPSK
+        mmtmpD0 = vmull_s16(dl_ch0_128[0], dl_ch0_128[0]);
+        // mmtmpD0 = [ch0*ch0,ch1*ch1,ch2*ch2,ch3*ch3];
+        mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
+        // mmtmpD0 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3]>>output_shift128 on 32-bits
+        mmtmpD1 = vmull_s16(dl_ch0_128[1], dl_ch0_128[1]);
+        mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
+        mmtmpD2 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
+        // mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits
+        mmtmpD0 = vmull_s16(dl_ch0_128[2], dl_ch0_128[2]);
+        mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
+        mmtmpD1 = vmull_s16(dl_ch0_128[3], dl_ch0_128[3]);
+        mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
+        mmtmpD3 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
+
+        if (pilots==0) {
+          mmtmpD0 = vmull_s16(dl_ch0_128[4], dl_ch0_128[4]);
+          mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
+          mmtmpD1 = vmull_s16(dl_ch0_128[5], dl_ch0_128[5]);
+          mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
+          mmtmpD4 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
+
+
+        }
+
+        dl_ch_mag0_128b[0] = vqdmulhq_s16(mmtmpD2,QAM_amp0_128b);
+        dl_ch_mag0_128b[1] = vqdmulhq_s16(mmtmpD3,QAM_amp0_128b);
+        dl_ch_mag0_128[0] = vqdmulhq_s16(mmtmpD2,QAM_amp0_128);
+        dl_ch_mag0_128[1] = vqdmulhq_s16(mmtmpD3,QAM_amp0_128);
+
+
+        if (pilots==0) {
+          dl_ch_mag0_128b[2] = vqdmulhq_s16(mmtmpD4,QAM_amp0_128b);
+          dl_ch_mag0_128[2]  = vqdmulhq_s16(mmtmpD4,QAM_amp0_128);
+        }
       }
 
       if (mod_order1>2) {
-	// get channel amplitude if not QPSK
-	mmtmpD0 = vmull_s16(dl_ch1_128[0], dl_ch1_128[0]);
-	// mmtmpD0 = [ch0*ch0,ch1*ch1,ch2*ch2,ch3*ch3];
-	mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
-	// mmtmpD0 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3]>>output_shift128 on 32-bits
-	mmtmpD1 = vmull_s16(dl_ch1_128[1], dl_ch1_128[1]);
-	mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
-	mmtmpD2 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	// mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits
-	mmtmpD0 = vmull_s16(dl_ch1_128[2], dl_ch1_128[2]);
-	mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
-	mmtmpD1 = vmull_s16(dl_ch1_128[3], dl_ch1_128[3]);
-	mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
-	mmtmpD3 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-
-	if (pilots==0) {
-	  mmtmpD0 = vmull_s16(dl_ch1_128[4], dl_ch1_128[4]);
-	  mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
-	  mmtmpD1 = vmull_s16(dl_ch1_128[5], dl_ch1_128[5]);
-	  mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
-	  mmtmpD4 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-
-
-	}
-
-	dl_ch_mag1_128b[0] = vqdmulhq_s16(mmtmpD2,QAM_amp1_128b);
-	dl_ch_mag1_128b[1] = vqdmulhq_s16(mmtmpD3,QAM_amp1_128b);
-	dl_ch_mag1_128[0] = vqdmulhq_s16(mmtmpD2,QAM_amp1_128);
-	dl_ch_mag1_128[1] = vqdmulhq_s16(mmtmpD3,QAM_amp1_128);
-
-
-	if (pilots==0) {
-	  dl_ch_mag1_128b[2] = vqdmulhq_s16(mmtmpD4,QAM_amp1_128b);
-	  dl_ch_mag1_128[2]  = vqdmulhq_s16(mmtmpD4,QAM_amp1_128);
-	}
+        // get channel amplitude if not QPSK
+        mmtmpD0 = vmull_s16(dl_ch1_128[0], dl_ch1_128[0]);
+        // mmtmpD0 = [ch0*ch0,ch1*ch1,ch2*ch2,ch3*ch3];
+        mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
+        // mmtmpD0 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3]>>output_shift128 on 32-bits
+        mmtmpD1 = vmull_s16(dl_ch1_128[1], dl_ch1_128[1]);
+        mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
+        mmtmpD2 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
+        // mmtmpD2 = [ch0*ch0 + ch1*ch1,ch0*ch0 + ch1*ch1,ch2*ch2 + ch3*ch3,ch2*ch2 + ch3*ch3,ch4*ch4 + ch5*ch5,ch4*ch4 + ch5*ch5,ch6*ch6 + ch7*ch7,ch6*ch6 + ch7*ch7]>>output_shift128 on 16-bits
+        mmtmpD0 = vmull_s16(dl_ch1_128[2], dl_ch1_128[2]);
+        mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
+        mmtmpD1 = vmull_s16(dl_ch1_128[3], dl_ch1_128[3]);
+        mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
+        mmtmpD3 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
+
+        if (pilots==0) {
+          mmtmpD0 = vmull_s16(dl_ch1_128[4], dl_ch1_128[4]);
+          mmtmpD0 = vqshlq_s32(vqaddq_s32(mmtmpD0,vrev64q_s32(mmtmpD0)),output_shift128);
+          mmtmpD1 = vmull_s16(dl_ch1_128[5], dl_ch1_128[5]);
+          mmtmpD1 = vqshlq_s32(vqaddq_s32(mmtmpD1,vrev64q_s32(mmtmpD1)),output_shift128);
+          mmtmpD4 = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
+
+
+        }
+
+        dl_ch_mag1_128b[0] = vqdmulhq_s16(mmtmpD2,QAM_amp1_128b);
+        dl_ch_mag1_128b[1] = vqdmulhq_s16(mmtmpD3,QAM_amp1_128b);
+        dl_ch_mag1_128[0] = vqdmulhq_s16(mmtmpD2,QAM_amp1_128);
+        dl_ch_mag1_128[1] = vqdmulhq_s16(mmtmpD3,QAM_amp1_128);
+
+
+        if (pilots==0) {
+          dl_ch_mag1_128b[2] = vqdmulhq_s16(mmtmpD4,QAM_amp1_128b);
+          dl_ch_mag1_128[2]  = vqdmulhq_s16(mmtmpD4,QAM_amp1_128);
+        }
       }
 
       mmtmpD0 = vmull_s16(dl_ch0_128[0], rxdataF128[0]);
@@ -2464,7 +2489,7 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
       mmtmpD1 = vmull_s16(dl_ch0_128[1], rxdataF128[1]);
       //mmtmpD1 = [Re(ch[2])Re(rx[2]) Im(ch[2])Im(ch[2]) Re(ch[3])Re(rx[3]) Im(ch[3])Im(ch[3])]
       mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
-			     vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
+                             vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
       //mmtmpD0 = [Re(ch[0])Re(rx[0])+Im(ch[0])Im(ch[0]) Re(ch[1])Re(rx[1])+Im(ch[1])Im(ch[1]) Re(ch[2])Re(rx[2])+Im(ch[2])Im(ch[2]) Re(ch[3])Re(rx[3])+Im(ch[3])Im(ch[3])]
 
       mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[0],*(int16x4_t*)conj)), rxdataF128[0]);
@@ -2472,7 +2497,7 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
       mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[1],*(int16x4_t*)conj)), rxdataF128[1]);
       //mmtmpD0 = [-Im(ch[2])Re(rx[2]) Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3]) Re(ch[3])Im(rx[3])]
       mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
-			     vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
+                             vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
       //mmtmpD1 = [-Im(ch[0])Re(rx[0])+Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1])+Re(ch[1])Im(rx[1]) -Im(ch[2])Re(rx[2])+Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3])+Re(ch[3])Im(rx[3])]
 
       mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
@@ -2482,12 +2507,12 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
       mmtmpD0 = vmull_s16(dl_ch0_128[2], rxdataF128[2]);
       mmtmpD1 = vmull_s16(dl_ch0_128[3], rxdataF128[3]);
       mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
-			     vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
+                             vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
 
       mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[2],*(int16x4_t*)conj)), rxdataF128[2]);
       mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[3],*(int16x4_t*)conj)), rxdataF128[3]);
       mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
-			     vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
+                             vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
 
       mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
       mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
@@ -2497,13 +2522,13 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
       mmtmpD0 = vmull_s16(dl_ch1_128[0], rxdataF128[0]);
       mmtmpD1 = vmull_s16(dl_ch1_128[1], rxdataF128[1]);
       mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
-			     vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
+                             vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
       mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[0],*(int16x4_t*)conj)), rxdataF128[0]);
 
       mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[1],*(int16x4_t*)conj)), rxdataF128[1]);
       //mmtmpD0 = [-Im(ch[2])Re(rx[2]) Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3]) Re(ch[3])Im(rx[3])]
       mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
-			     vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
+                             vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
       //mmtmpD1 = [-Im(ch[0])Re(rx[0])+Re(ch[0])Im(rx[0]) -Im(ch[1])Re(rx[1])+Re(ch[1])Im(rx[1]) -Im(ch[2])Re(rx[2])+Re(ch[2])Im(rx[2]) -Im(ch[3])Re(rx[3])+Re(ch[3])Im(rx[3])]
 
       mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
@@ -2513,46 +2538,46 @@ void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
       mmtmpD0 = vmull_s16(dl_ch1_128[2], rxdataF128[2]);
       mmtmpD1 = vmull_s16(dl_ch1_128[3], rxdataF128[3]);
       mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
-			     vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
+                             vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
 
       mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[2],*(int16x4_t*)conj)), rxdataF128[2]);
       mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[3],*(int16x4_t*)conj)), rxdataF128[3]);
       mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
-			     vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
+                             vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
 
       mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
       mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
       rxdataF_comp1_128[1] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
 
       if (pilots==0) {
-	mmtmpD0 = vmull_s16(dl_ch0_128[4], rxdataF128[4]);
-	mmtmpD1 = vmull_s16(dl_ch0_128[5], rxdataF128[5]);
-	mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
-			       vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
-
-	mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[4],*(int16x4_t*)conj)), rxdataF128[4]);
-	mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[5],*(int16x4_t*)conj)), rxdataF128[5]);
-	mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
-			       vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
-
-
-	mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
-	mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
-	rxdataF_comp0_128[2] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
-	mmtmpD0 = vmull_s16(dl_ch1_128[4], rxdataF128[4]);
-	mmtmpD1 = vmull_s16(dl_ch1_128[5], rxdataF128[5]);
-	mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
-			       vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
-
-	mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch1_128[4],*(int16x4_t*)conj)), rxdataF128[4]);
-	mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch1_128[5],*(int16x4_t*)conj)), rxdataF128[5]);
-	mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
-			       vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
-
-
-	mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
-	mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
-	rxdataF_comp1_128[2] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
+        mmtmpD0 = vmull_s16(dl_ch0_128[4], rxdataF128[4]);
+        mmtmpD1 = vmull_s16(dl_ch0_128[5], rxdataF128[5]);
+        mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
+                               vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
+
+        mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[4],*(int16x4_t*)conj)), rxdataF128[4]);
+        mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch0_128[5],*(int16x4_t*)conj)), rxdataF128[5]);
+        mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
+                               vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
+
+
+        mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
+        mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
+        rxdataF_comp0_128[2] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
+        mmtmpD0 = vmull_s16(dl_ch1_128[4], rxdataF128[4]);
+        mmtmpD1 = vmull_s16(dl_ch1_128[5], rxdataF128[5]);
+        mmtmpD0 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0),vget_high_s32(mmtmpD0)),
+                               vpadd_s32(vget_low_s32(mmtmpD1),vget_high_s32(mmtmpD1)));
+
+        mmtmpD0b = vmull_s16(vrev32_s16(vmul_s16(dl_ch1_128[4],*(int16x4_t*)conj)), rxdataF128[4]);
+        mmtmpD1b = vmull_s16(vrev32_s16(vmul_s16(dl_ch1_128[5],*(int16x4_t*)conj)), rxdataF128[5]);
+        mmtmpD1 = vcombine_s32(vpadd_s32(vget_low_s32(mmtmpD0b),vget_high_s32(mmtmpD0b)),
+                               vpadd_s32(vget_low_s32(mmtmpD1b),vget_high_s32(mmtmpD1b)));
+
+
+        mmtmpD0 = vqshlq_s32(mmtmpD0,output_shift128);
+        mmtmpD1 = vqshlq_s32(mmtmpD1,output_shift128);
+        rxdataF_comp1_128[2] = vcombine_s16(vmovn_s32(mmtmpD0),vmovn_s32(mmtmpD1));
       }
     }
 
@@ -2700,7 +2725,7 @@ void dlsch_dual_stream_correlation(LTE_DL_FRAME_PARMS *frame_parms,
                                    int **dl_ch_estimates_ext_i,
                                    int **dl_ch_rho_ext,
                                    unsigned char output_shift0,
-				   unsigned char output_shift1)
+                                   unsigned char output_shift1)
 {
 
 #if defined(__x86_64__)||defined(__i386__)
@@ -2726,7 +2751,7 @@ void dlsch_dual_stream_correlation(LTE_DL_FRAME_PARMS *frame_parms,
       output_shift=output_shift0;
     }
       else {
-	output_shift=output_shift1;
+        output_shift=output_shift1;
       }
 
  //printf ("antenna %d", aarx);
@@ -2852,8 +2877,8 @@ void dlsch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms,
         dl_ch_mag128_0[i]    = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0[i],1),_mm_srai_epi16(dl_ch_mag128_1[i],1));
         dl_ch_mag128_0b[i]   = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0b[i],1),_mm_srai_epi16(dl_ch_mag128_1b[i],1));
           //       print_shorts("mrc comp0:",&rxdataF_comp128_0[i]);
-	//	 print_shorts("mrc mag0:",&dl_ch_mag128_0[i]);
-	//	 print_shorts("mrc mag0b:",&dl_ch_mag128_0b[i]);
+        //       print_shorts("mrc mag0:",&dl_ch_mag128_0[i]);
+        //       print_shorts("mrc mag0b:",&dl_ch_mag128_0b[i]);
         //      print_shorts("mrc rho1:",&rho128_1[i]);
 
       }
@@ -2956,25 +2981,25 @@ void dlsch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms,
 
 
 void dlsch_detection_mrc_TM34(LTE_DL_FRAME_PARMS *frame_parms,
-			      LTE_UE_PDSCH *lte_ue_pdsch_vars,
-			      int harq_pid,
-			      int round,
-			      unsigned char symbol,
-			      unsigned short nb_rb,
-			      unsigned char dual_stream_UE) {
+                              LTE_UE_PDSCH *lte_ue_pdsch_vars,
+                              int harq_pid,
+                              int round,
+                              unsigned char symbol,
+                              unsigned short nb_rb,
+                              unsigned char dual_stream_UE) {
 
   unsigned char aatx;
   int i;
   __m128i *rxdataF_comp128_0,*rxdataF_comp128_1,*rxdataF_comp128_i0,*rxdataF_comp128_i1,*dl_ch_mag128_0,*dl_ch_mag128_1,*dl_ch_mag128_0b,*dl_ch_mag128_1b,*rho128_0,*rho128_1,*rho128_i0,*rho128_i1,*dl_ch_mag128_i0,*dl_ch_mag128_i1,*dl_ch_mag128_i0b,*dl_ch_mag128_i1b;
 
-  int **rxdataF_comp0 		=lte_ue_pdsch_vars->rxdataF_comp0;
-  int **rxdataF_comp1 		=lte_ue_pdsch_vars->rxdataF_comp1[harq_pid][round];
-  int **dl_ch_rho_ext 		=lte_ue_pdsch_vars->dl_ch_rho_ext[harq_pid][round]; //for second stream
-  int **dl_ch_rho2_ext 		=lte_ue_pdsch_vars->dl_ch_rho2_ext;
-  int **dl_ch_mag0            	= lte_ue_pdsch_vars->dl_ch_mag0;
-  int **dl_ch_mag1            	= lte_ue_pdsch_vars->dl_ch_mag1[harq_pid][round];
-  int **dl_ch_magb0           	= lte_ue_pdsch_vars->dl_ch_magb0;
-  int **dl_ch_magb1           	= lte_ue_pdsch_vars->dl_ch_magb1[harq_pid][round];
+  int **rxdataF_comp0           =lte_ue_pdsch_vars->rxdataF_comp0;
+  int **rxdataF_comp1           =lte_ue_pdsch_vars->rxdataF_comp1[harq_pid][round];
+  int **dl_ch_rho_ext           =lte_ue_pdsch_vars->dl_ch_rho_ext[harq_pid][round]; //for second stream
+  int **dl_ch_rho2_ext          =lte_ue_pdsch_vars->dl_ch_rho2_ext;
+  int **dl_ch_mag0              = lte_ue_pdsch_vars->dl_ch_mag0;
+  int **dl_ch_mag1              = lte_ue_pdsch_vars->dl_ch_mag1[harq_pid][round];
+  int **dl_ch_magb0             = lte_ue_pdsch_vars->dl_ch_magb0;
+  int **dl_ch_magb1             = lte_ue_pdsch_vars->dl_ch_magb1[harq_pid][round];
 
 
   if (frame_parms->nb_antennas_rx>1) {
@@ -2992,9 +3017,9 @@ void dlsch_detection_mrc_TM34(LTE_DL_FRAME_PARMS *frame_parms,
         dl_ch_mag128_0[i]    = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0[i],1),_mm_srai_epi16(dl_ch_mag128_1[i],1));
         dl_ch_mag128_0b[i]   = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_0b[i],1),_mm_srai_epi16(dl_ch_mag128_1b[i],1));
 
-	// print_shorts("mrc compens0:",&rxdataF_comp128_0[i]);
-	// print_shorts("mrc mag128_0:",&dl_ch_mag128_0[i]);
-	// print_shorts("mrc mag128_0b:",&dl_ch_mag128_0b[i]);
+        // print_shorts("mrc compens0:",&rxdataF_comp128_0[i]);
+        // print_shorts("mrc mag128_0:",&dl_ch_mag128_0[i]);
+        // print_shorts("mrc mag128_0b:",&dl_ch_mag128_0b[i]);
       }    }
 
    // if (rho) {
@@ -3024,9 +3049,9 @@ void dlsch_detection_mrc_TM34(LTE_DL_FRAME_PARMS *frame_parms,
         dl_ch_mag128_i0[i]    = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_i0[i],1),_mm_srai_epi16(dl_ch_mag128_i1[i],1));
         dl_ch_mag128_i0b[i]    = _mm_adds_epi16(_mm_srai_epi16(dl_ch_mag128_i0b[i],1),_mm_srai_epi16(dl_ch_mag128_i1b[i],1));
 
-	//print_shorts("mrc compens1:",&rxdataF_comp128_i0[i]);
-	//print_shorts("mrc mag128_i0:",&dl_ch_mag128_i0[i]);
-	//print_shorts("mrc mag128_i0b:",&dl_ch_mag128_i0b[i]);
+        //print_shorts("mrc compens1:",&rxdataF_comp128_i0[i]);
+        //print_shorts("mrc mag128_i0:",&dl_ch_mag128_i0[i]);
+        //print_shorts("mrc mag128_i0b:",&dl_ch_mag128_i0b[i]);
       }
     }
 
@@ -3228,9 +3253,9 @@ void dlsch_channel_level(int **dl_ch_estimates_ext,
 //compute average channel_level of effective (precoded) channel
 void dlsch_channel_level_TM34(int **dl_ch_estimates_ext,
                               LTE_DL_FRAME_PARMS *frame_parms,
-			      unsigned char *pmi_ext,
+                              unsigned char *pmi_ext,
                               int *avg_0,
-			      int *avg_1,
+                              int *avg_1,
                               uint8_t symbol,
                               unsigned short nb_rb,
                               MIMO_mode_t mimo_mode){
@@ -3269,7 +3294,7 @@ void dlsch_channel_level_TM34(int **dl_ch_estimates_ext,
     for (rb=0; rb<nb_rb; rb++) {
               // printf("rb %d : \n",rb);
               // print_shorts("ch0\n",&dl_ch0_128[0]);
-	       //print_shorts("ch1\n",&dl_ch1_128[0]);
+               //print_shorts("ch1\n",&dl_ch1_128[0]);
       dl_ch0_128_tmp = _mm_load_si128(&dl_ch0_128[0]);
       dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[0]);
 
@@ -3318,12 +3343,12 @@ void dlsch_channel_level_TM34(int **dl_ch_estimates_ext,
           prec2A_TM4_128(0,&dl_ch0_128_tmp,&dl_ch1_128_tmp);
         else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODINGj)
           prec2A_TM4_128(1,&dl_ch0_128_tmp,&dl_ch1_128_tmp);
-	else if (mimo_mode==DUALSTREAM_PUSCH_PRECODING)
-	  prec2A_TM4_128(pmi_ext[rb],&dl_ch0_128_tmp,&dl_ch1_128_tmp);
+        else if (mimo_mode==DUALSTREAM_PUSCH_PRECODING)
+          prec2A_TM4_128(pmi_ext[rb],&dl_ch0_128_tmp,&dl_ch1_128_tmp);
         //      mmtmpD2 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);
 
-	avg_1_128D = _mm_add_epi32(avg_1_128D,_mm_madd_epi16(dl_ch1_128_tmp,dl_ch1_128_tmp));
-	avg_0_128D = _mm_add_epi32(avg_0_128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
+        avg_1_128D = _mm_add_epi32(avg_1_128D,_mm_madd_epi16(dl_ch1_128_tmp,dl_ch1_128_tmp));
+        avg_0_128D = _mm_add_epi32(avg_0_128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
 
         dl_ch0_128+=3;
         dl_ch1_128+=3;
@@ -3720,7 +3745,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
         else
           rb_alloc_ind = 0;
 
-	if (rb_alloc_ind == 1)
+        if (rb_alloc_ind == 1)
           nb_rb++;
 
         // For second half of RBs skip DC carrier
@@ -3759,17 +3784,17 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
           memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int));
 
           /*
-	    printf("rb %d\n",rb);
-	    for (i=0;i<12;i++)
-	    printf("(%d %d)",((short *)dl_ch0)[i<<1],((short*)dl_ch0)[1+(i<<1)]);
-	    printf("\n");
+            printf("rb %d\n",rb);
+            for (i=0;i<12;i++)
+            printf("(%d %d)",((short *)dl_ch0)[i<<1],((short*)dl_ch0)[1+(i<<1)]);
+            printf("\n");
           */
           if (pilots==0) {
             for (i=0; i<12; i++) {
               rxF_ext[i]=rxF[i];
               /*
-		printf("%d : (%d,%d)\n",(rxF+i-&rxdataF[aarx][( (symbol*(frame_parms->ofdm_symbol_size)))]),
-		((short*)&rxF[i])[0],((short*)&rxF[i])[1]);*/
+                printf("%d : (%d,%d)\n",(rxF+i-&rxdataF[aarx][( (symbol*(frame_parms->ofdm_symbol_size)))]),
+                ((short*)&rxF[i])[0],((short*)&rxF[i])[1]);*/
             }
 
             dl_ch0_ext+=12;
@@ -3801,7 +3826,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
     else {  // Odd number of RBs
       for (rb=0; rb<frame_parms->N_RB_DL>>1; rb++) {
 #ifdef DEBUG_DLSCH_DEMOD
-	printf("dlch_ext %d\n",dl_ch0_ext-&dl_ch_estimates_ext[aarx][0]);
+        printf("dlch_ext %d\n",dl_ch0_ext-&dl_ch_estimates_ext[aarx][0]);
 #endif
         skip_half=0;
 
@@ -3816,8 +3841,8 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
         else
           rb_alloc_ind = 0;
 
-	if (rb_alloc_ind == 1)
-	  nb_rb++;
+        if (rb_alloc_ind == 1)
+          nb_rb++;
 
 
         // PBCH
@@ -3853,9 +3878,9 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
         if (frame_parms->frame_type == FDD) {  //FDD
 
           if (((subframe==0)||(subframe==5)) &&
-	      (rb>((frame_parms->N_RB_DL>>1)-3)) &&
-	      (rb<((frame_parms->N_RB_DL>>1)+3)) &&
-	      (l==pss_symb) ) {
+              (rb>((frame_parms->N_RB_DL>>1)-3)) &&
+              (rb<((frame_parms->N_RB_DL>>1)+3)) &&
+              (l==pss_symb) ) {
             rb_alloc_ind = 0;
           }
 
@@ -3880,19 +3905,19 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
         if (rb_alloc_ind==1) {
 
 #ifdef DEBUG_DLSCH_DEMOD
-	  printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half);
+          printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half);
 #endif
           if (pilots==0) {
-	    //	    printf("Extracting w/o pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half);
+            //      printf("Extracting w/o pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half);
             if (skip_half==1) {
               memcpy(dl_ch0_ext,dl_ch0,6*sizeof(int));
 
               for (i=0; i<6; i++) {
-	        rxF_ext[i]=rxF[i];
+                rxF_ext[i]=rxF[i];
 #ifdef DEBUG_DLSCH_DEMOD
-		printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
+                printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
 #endif
-	      }
+              }
               dl_ch0_ext+=6;
               rxF_ext+=6;
             } else if (skip_half==2) {
@@ -3901,9 +3926,9 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
               for (i=0; i<6; i++) {
                 rxF_ext[i]=rxF[(i+6)];
 #ifdef DEBUG_DLSCH_DEMOD
-		printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
+                printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
 #endif
-	      }
+              }
               dl_ch0_ext+=6;
               rxF_ext+=6;
             } else {
@@ -3914,12 +3939,12 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
 #ifdef DEBUG_DLSCH_DEMOD
                 printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
 #endif
-	      }
+              }
               dl_ch0_ext+=12;
               rxF_ext+=12;
             }
           } else {
-	    //	    printf("Extracting with pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half);
+            //      printf("Extracting with pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half);
             j=0;
 
             if (skip_half==1) {
@@ -3932,14 +3957,14 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
                   dl_ch0_ext[j++]=dl_ch0[i];
                 }
               }
-	      rxF_ext+=5;
+              rxF_ext+=5;
               dl_ch0_ext+=5;
             } else if (skip_half==2) {
               for (i=0; i<6; i++) {
                 if (i!=((frame_parms->nushift+poffset)%6)) {
                   rxF_ext[j]=rxF[(i+6)];
 #ifdef DEBUG_DLSCH_DEMOD
-		  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
 #endif
                   dl_ch0_ext[j++]=dl_ch0[i+6];
                 }
@@ -3953,7 +3978,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
                     (i!=((frame_parms->nushift+poffset+6)%12))) {
                   rxF_ext[j]=rxF[i];
 #ifdef DEBUG_DLSCH_DEMOD
-		  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
 #endif
                   dl_ch0_ext[j++]=dl_ch0[i];
 
@@ -3984,13 +4009,13 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
 
 
       if (rb_alloc_ind == 1)
-	nb_rb++;
+        nb_rb++;
 
       // PBCH
 
       if ((subframe==0) &&
-	  (l>=(nsymb>>1)) &&
-	  (l<((nsymb>>1) + 4))) {
+          (l>=(nsymb>>1)) &&
+          (l<((nsymb>>1) + 4))) {
         rb_alloc_ind = 0;
       }
 
@@ -4009,8 +4034,8 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
       //PSS
       if ((frame_parms->frame_type == TDD) &&
           (subframe==6) &&
-	  (l==pss_symb) ) {
-	rb_alloc_ind = 0;
+          (l==pss_symb) ) {
+        rb_alloc_ind = 0;
       }
 
 
@@ -4018,7 +4043,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
       //      printf("DC rb %d (%p)\n",rb,rxF);
       if (rb_alloc_ind==1) {
 #ifdef DEBUG_DLSCH_DEMOD
-	printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half);
+        printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half);
 #endif
         if (pilots==0) {
           for (i=0; i<6; i++) {
@@ -4088,8 +4113,8 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
         else
           rb_alloc_ind = 0;
 
-	if (rb_alloc_ind == 1)
-	  nb_rb++;
+        if (rb_alloc_ind == 1)
+          nb_rb++;
 
         // PBCH
         if ((subframe==0) && (rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l>=nsymb>>1) && (l<((nsymb>>1) + 4))) {
@@ -4139,25 +4164,25 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
 
         if (rb_alloc_ind==1) {
 #ifdef DEBUG_DLSCH_DEMOD
-	  printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half);
+          printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half);
 #endif
           /*
-	    printf("rb %d\n",rb);
+            printf("rb %d\n",rb);
             for (i=0;i<12;i++)
             printf("(%d %d)",((short *)dl_ch0)[i<<1],((short*)dl_ch0)[1+(i<<1)]);
             printf("\n");
           */
           if (pilots==0) {
-	    //	    printf("Extracting w/o pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half);
+            //      printf("Extracting w/o pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half);
             if (skip_half==1) {
               memcpy(dl_ch0_ext,dl_ch0,6*sizeof(int));
 
               for (i=0; i<6; i++) {
                 rxF_ext[i]=rxF[i];
 #ifdef DEBUG_DLSCH_DEMOD
-		printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
+                printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
 #endif
-	      }
+              }
               dl_ch0_ext+=6;
               rxF_ext+=6;
 
@@ -4167,9 +4192,9 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
               for (i=0; i<6; i++) {
                 rxF_ext[i]=rxF[(i+6)];
 #ifdef DEBUG_DLSCH_DEMOD
-		printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
+                printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
 #endif
-	      }
+              }
               dl_ch0_ext+=6;
               rxF_ext+=6;
 
@@ -4179,14 +4204,14 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
               for (i=0; i<12; i++) {
                 rxF_ext[i]=rxF[i];
 #ifdef DEBUG_DLSCH_DEMOD
-		printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
+                printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
 #endif
-	      }
+              }
               dl_ch0_ext+=12;
               rxF_ext+=12;
             }
           } else {
-	    //	    printf("Extracting with pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half);
+            //      printf("Extracting with pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half);
             j=0;
 
             if (skip_half==1) {
@@ -4194,7 +4219,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
                 if (i!=((frame_parms->nushift+poffset)%6)) {
                   rxF_ext[j]=rxF[i];
 #ifdef DEBUG_DLSCH_DEMOD
-		  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
 #endif
                   dl_ch0_ext[j++]=dl_ch0[i];
                 }
@@ -4207,7 +4232,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
                 if (i!=((frame_parms->nushift+poffset)%6)) {
                   rxF_ext[j]=rxF[(i+6)];
 #ifdef DEBUG_DLSCH_DEMOD
-		  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
 #endif
                   dl_ch0_ext[j++]=dl_ch0[i+6];
                 }
@@ -4221,7 +4246,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
                     (i!=((frame_parms->nushift+poffset+6)%12))) {
                   rxF_ext[j]=rxF[i];
 #ifdef DEBUG_DLSCH_DEMOD
-		  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
 #endif
                   dl_ch0_ext[j++]=dl_ch0[i];
                 }
@@ -4253,7 +4278,7 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
                                       unsigned char subframe,
                                       uint32_t high_speed_flag,
                                       LTE_DL_FRAME_PARMS *frame_parms,
-				                              MIMO_mode_t mimo_mode) {
+                                                              MIMO_mode_t mimo_mode) {
 
   int prb,nb_rb=0;
   int prb_off,prb_off2;
@@ -4301,15 +4326,15 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
       skip_half=0;
 
       if (prb < 32)
-	rb_alloc_ind = (rb_alloc[0]>>prb) & 1;
+        rb_alloc_ind = (rb_alloc[0]>>prb) & 1;
       else if (prb < 64)
-	rb_alloc_ind = (rb_alloc[1]>>(prb-32)) & 1;
+        rb_alloc_ind = (rb_alloc[1]>>(prb-32)) & 1;
       else if (prb < 96)
-	rb_alloc_ind = (rb_alloc[2]>>(prb-64)) & 1;
+        rb_alloc_ind = (rb_alloc[2]>>(prb-64)) & 1;
       else if (prb < 100)
-	rb_alloc_ind = (rb_alloc[3]>>(prb-96)) & 1;
+        rb_alloc_ind = (rb_alloc[3]>>(prb-96)) & 1;
       else
-	rb_alloc_ind = 0;
+        rb_alloc_ind = 0;
 
       if (rb_alloc_ind == 1)
           nb_rb++;
@@ -4317,73 +4342,73 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
 
       if ((frame_parms->N_RB_DL&1) == 0) {  // even number of RBs
 
-	// PBCH
-	if ((subframe==0) &&
-	    (prb>=((frame_parms->N_RB_DL>>1)-3)) &&
-	    (prb<((frame_parms->N_RB_DL>>1)+3)) &&
-	    (l>=(nsymb>>1)) &&
-	    (l<((nsymb>>1) + 4))) {
-	  rb_alloc_ind = 0;
-	  //	printf("symbol %d / rb %d: skipping PBCH REs\n",symbol,prb);
-	}
-
-	//SSS
-
-	if (((subframe==0)||(subframe==5)) &&
-	    (prb>=((frame_parms->N_RB_DL>>1)-3)) &&
-	    (prb<((frame_parms->N_RB_DL>>1)+3)) &&
-	    (l==sss_symb) ) {
-	  rb_alloc_ind = 0;
-	  //	printf("symbol %d / rb %d: skipping SSS REs\n",symbol,prb);
-	}
-
-
-
-	//PSS in subframe 0/5 if FDD
-	if (frame_parms->frame_type == FDD) {  //FDD
-	  if (((subframe==0)||(subframe==5)) &&
-	      (prb>=((frame_parms->N_RB_DL>>1)-3)) &&
-	      (prb<((frame_parms->N_RB_DL>>1)+3)) &&
-	      (l==pss_symb) ) {
-	    rb_alloc_ind = 0;
-	    //	  printf("symbol %d / rb %d: skipping PSS REs\n",symbol,prb);
-	  }
-	}
-
-	if ((frame_parms->frame_type == TDD) &&
-	    (subframe==6)) { //TDD Subframe 6
-	  if ((prb>=((frame_parms->N_RB_DL>>1)-3)) &&
-	      (prb<((frame_parms->N_RB_DL>>1)+3)) &&
-	      (l==pss_symb) ) {
-	    rb_alloc_ind = 0;
-	  }
-	}
-
-	if (rb_alloc_ind==1) {              // PRB is allocated
-
-
-
-	  prb_off      = 12*prb;
-	  prb_off2     = 1+(12*(prb-(frame_parms->N_RB_DL>>1)));
-	  dl_ch0p    = dl_ch0+(12*prb);
-	  dl_ch1p    = dl_ch1+(12*prb);
-	  if (prb<(frame_parms->N_RB_DL>>1)){
-	    rxF      = &rxdataF[aarx][prb_off+
-				      frame_parms->first_carrier_offset +
-				      (symbol*(frame_parms->ofdm_symbol_size))];
-	  }
-	  else {
-	    rxF      = &rxdataF[aarx][prb_off2+
-				      (symbol*(frame_parms->ofdm_symbol_size))];
-	  }
-
-	 /*
-	 if (mimo_mode <= PUSCH_PRECODING1)
+        // PBCH
+        if ((subframe==0) &&
+            (prb>=((frame_parms->N_RB_DL>>1)-3)) &&
+            (prb<((frame_parms->N_RB_DL>>1)+3)) &&
+            (l>=(nsymb>>1)) &&
+            (l<((nsymb>>1) + 4))) {
+          rb_alloc_ind = 0;
+          //    printf("symbol %d / rb %d: skipping PBCH REs\n",symbol,prb);
+        }
+
+        //SSS
+
+        if (((subframe==0)||(subframe==5)) &&
+            (prb>=((frame_parms->N_RB_DL>>1)-3)) &&
+            (prb<((frame_parms->N_RB_DL>>1)+3)) &&
+            (l==sss_symb) ) {
+          rb_alloc_ind = 0;
+          //    printf("symbol %d / rb %d: skipping SSS REs\n",symbol,prb);
+        }
+
+
+
+        //PSS in subframe 0/5 if FDD
+        if (frame_parms->frame_type == FDD) {  //FDD
+          if (((subframe==0)||(subframe==5)) &&
+              (prb>=((frame_parms->N_RB_DL>>1)-3)) &&
+              (prb<((frame_parms->N_RB_DL>>1)+3)) &&
+              (l==pss_symb) ) {
+            rb_alloc_ind = 0;
+            //    printf("symbol %d / rb %d: skipping PSS REs\n",symbol,prb);
+          }
+        }
+
+        if ((frame_parms->frame_type == TDD) &&
+            (subframe==6)) { //TDD Subframe 6
+          if ((prb>=((frame_parms->N_RB_DL>>1)-3)) &&
+              (prb<((frame_parms->N_RB_DL>>1)+3)) &&
+              (l==pss_symb) ) {
+            rb_alloc_ind = 0;
+          }
+        }
+
+        if (rb_alloc_ind==1) {              // PRB is allocated
+
+
+
+          prb_off      = 12*prb;
+          prb_off2     = 1+(12*(prb-(frame_parms->N_RB_DL>>1)));
+          dl_ch0p    = dl_ch0+(12*prb);
+          dl_ch1p    = dl_ch1+(12*prb);
+          if (prb<(frame_parms->N_RB_DL>>1)){
+            rxF      = &rxdataF[aarx][prb_off+
+                                      frame_parms->first_carrier_offset +
+                                      (symbol*(frame_parms->ofdm_symbol_size))];
+          }
+          else {
+            rxF      = &rxdataF[aarx][prb_off2+
+                                      (symbol*(frame_parms->ofdm_symbol_size))];
+          }
+
+         /*
+         if (mimo_mode <= PUSCH_PRECODING1)
           *pmi_loc = (pmi>>((prb>>2)<<1))&3;
-	 else
-	  *pmi_loc=(pmi>>prb)&1;*/
+         else
+          *pmi_loc=(pmi>>prb)&1;*/
 
-	 *pmi_loc = get_pmi(frame_parms->N_RB_DL,mimo_mode,pmi,prb);
+         *pmi_loc = get_pmi(frame_parms->N_RB_DL,mimo_mode,pmi,prb);
           pmi_loc++;
 
 
@@ -4408,280 +4433,280 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
                 dl_ch1_ext[j++]=dl_ch1p[i];
               }
             }
-	    dl_ch0_ext+=8;
-	    dl_ch1_ext+=8;
-	    rxF_ext+=8;
+            dl_ch0_ext+=8;
+            dl_ch1_ext+=8;
+            rxF_ext+=8;
           } // pilots==1
 
-	}
+        }
       } else {  // Odd number of RBs
 
 
       // PBCH
-	if ((subframe==0) &&
-	    (prb>((frame_parms->N_RB_DL>>1)-3)) &&
-	    (prb<((frame_parms->N_RB_DL>>1)+3)) &&
-	    (l>=(nsymb>>1)) &&
-	    (l<((nsymb>>1) + 4))) {
-	  rb_alloc_ind = 0;
-	  //	printf("symbol %d / rb %d: skipping PBCH REs\n",symbol,prb);
-	}
-
-	//SSS
-
-	if (((subframe==0)||(subframe==5)) &&
-	    (prb>((frame_parms->N_RB_DL>>1)-3)) &&
-	    (prb<((frame_parms->N_RB_DL>>1)+3)) &&
-	    (l==sss_symb) ) {
-	  rb_alloc_ind = 0;
-	  //	printf("symbol %d / rb %d: skipping SSS REs\n",symbol,prb);
-	}
-
-
-
-	//PSS in subframe 0/5 if FDD
-	if (frame_parms->frame_type == FDD) {  //FDD
-	  if (((subframe==0)||(subframe==5)) &&
-	      (prb>((frame_parms->N_RB_DL>>1)-3)) &&
-	      (prb<((frame_parms->N_RB_DL>>1)+3)) &&
-	      (l==pss_symb) ) {
-	    rb_alloc_ind = 0;
-	    //	  printf("symbol %d / rb %d: skipping PSS REs\n",symbol,prb);
-	  }
-	}
-
-	if ((frame_parms->frame_type == TDD) &&
-	    ((subframe==1) || (subframe==6))) { //TDD Subframe 1-6
-	  if ((prb>((frame_parms->N_RB_DL>>1)-3)) &&
-	      (prb<((frame_parms->N_RB_DL>>1)+3)) &&
-	      (l==pss_symb) ) {
-	    rb_alloc_ind = 0;
-	  }
-	}
-
-	if (rb_alloc_ind == 1) {
-	  skip_half=0;
-
-	  //Check if we have to drop half a PRB due to PSS/SSS/PBCH
-	  // skip_half == 0 means full PRB
-	  // skip_half == 1 means first half is used (leftmost half-PRB from PSS/SSS/PBCH)
-	  // skip_half == 2 means second half is used (rightmost half-PRB from PSS/SSS/PBCH)
-	  //PBCH subframe 0, symbols nsymb>>1 ... nsymb>>1 + 3
-	  if ((subframe==0) &&
-	      (prb==((frame_parms->N_RB_DL>>1)-3)) &&
-	      (l>=(nsymb>>1)) &&
-	      (l<((nsymb>>1) + 4)))
-	    skip_half=1;
-	  else if ((subframe==0) &&
-		   (prb==((frame_parms->N_RB_DL>>1)+3)) &&
-		   (l>=(nsymb>>1)) &&
-		   (l<((nsymb>>1) + 4)))
-	    skip_half=2;
-
-	  //SSS
-	  if (((subframe==0)||(subframe==5)) &&
-	      (prb==((frame_parms->N_RB_DL>>1)-3)) &&
-	      (l==sss_symb))
-	    skip_half=1;
-	  else if (((subframe==0)||(subframe==5)) &&
-		   (prb==((frame_parms->N_RB_DL>>1)+3)) &&
-		   (l==sss_symb))
-	    skip_half=2;
-
-	  //PSS Subframe 0,5
-	  if (((frame_parms->frame_type == FDD) &&
-	       (((subframe==0)||(subframe==5)))) ||  //FDD Subframes 0,5
-	      ((frame_parms->frame_type == TDD) &&
-	       (((subframe==1) || (subframe==6))))) { //TDD Subframes 1,6
-
-	    if ((prb==((frame_parms->N_RB_DL>>1)-3)) &&
-		(l==pss_symb))
-	      skip_half=1;
-	    else if ((prb==((frame_parms->N_RB_DL>>1)+3)) &&
-		     (l==pss_symb))
-	      skip_half=2;
-	  }
-
-
-	  prb_off      = 12*prb;
-	  prb_off2     = 7+(12*(prb-(frame_parms->N_RB_DL>>1)-1));
-	  dl_ch0p      = dl_ch0+(12*prb);
-	  dl_ch1p      = dl_ch1+(12*prb);
-
-	  if (prb<=(frame_parms->N_RB_DL>>1)){
-	    rxF      = &rxdataF[aarx][prb_off+
-				      frame_parms->first_carrier_offset +
-				      (symbol*(frame_parms->ofdm_symbol_size))];
-	  }
-	  else {
-	    rxF      = &rxdataF[aarx][prb_off2+
-				      (symbol*(frame_parms->ofdm_symbol_size))];
-	  }
+        if ((subframe==0) &&
+            (prb>((frame_parms->N_RB_DL>>1)-3)) &&
+            (prb<((frame_parms->N_RB_DL>>1)+3)) &&
+            (l>=(nsymb>>1)) &&
+            (l<((nsymb>>1) + 4))) {
+          rb_alloc_ind = 0;
+          //    printf("symbol %d / rb %d: skipping PBCH REs\n",symbol,prb);
+        }
+
+        //SSS
+
+        if (((subframe==0)||(subframe==5)) &&
+            (prb>((frame_parms->N_RB_DL>>1)-3)) &&
+            (prb<((frame_parms->N_RB_DL>>1)+3)) &&
+            (l==sss_symb) ) {
+          rb_alloc_ind = 0;
+          //    printf("symbol %d / rb %d: skipping SSS REs\n",symbol,prb);
+        }
+
+
+
+        //PSS in subframe 0/5 if FDD
+        if (frame_parms->frame_type == FDD) {  //FDD
+          if (((subframe==0)||(subframe==5)) &&
+              (prb>((frame_parms->N_RB_DL>>1)-3)) &&
+              (prb<((frame_parms->N_RB_DL>>1)+3)) &&
+              (l==pss_symb) ) {
+            rb_alloc_ind = 0;
+            //    printf("symbol %d / rb %d: skipping PSS REs\n",symbol,prb);
+          }
+        }
+
+        if ((frame_parms->frame_type == TDD) &&
+            ((subframe==1) || (subframe==6))) { //TDD Subframe 1-6
+          if ((prb>((frame_parms->N_RB_DL>>1)-3)) &&
+              (prb<((frame_parms->N_RB_DL>>1)+3)) &&
+              (l==pss_symb) ) {
+            rb_alloc_ind = 0;
+          }
+        }
+
+        if (rb_alloc_ind == 1) {
+          skip_half=0;
+
+          //Check if we have to drop half a PRB due to PSS/SSS/PBCH
+          // skip_half == 0 means full PRB
+          // skip_half == 1 means first half is used (leftmost half-PRB from PSS/SSS/PBCH)
+          // skip_half == 2 means second half is used (rightmost half-PRB from PSS/SSS/PBCH)
+          //PBCH subframe 0, symbols nsymb>>1 ... nsymb>>1 + 3
+          if ((subframe==0) &&
+              (prb==((frame_parms->N_RB_DL>>1)-3)) &&
+              (l>=(nsymb>>1)) &&
+              (l<((nsymb>>1) + 4)))
+            skip_half=1;
+          else if ((subframe==0) &&
+                   (prb==((frame_parms->N_RB_DL>>1)+3)) &&
+                   (l>=(nsymb>>1)) &&
+                   (l<((nsymb>>1) + 4)))
+            skip_half=2;
+
+          //SSS
+          if (((subframe==0)||(subframe==5)) &&
+              (prb==((frame_parms->N_RB_DL>>1)-3)) &&
+              (l==sss_symb))
+            skip_half=1;
+          else if (((subframe==0)||(subframe==5)) &&
+                   (prb==((frame_parms->N_RB_DL>>1)+3)) &&
+                   (l==sss_symb))
+            skip_half=2;
+
+          //PSS Subframe 0,5
+          if (((frame_parms->frame_type == FDD) &&
+               (((subframe==0)||(subframe==5)))) ||  //FDD Subframes 0,5
+              ((frame_parms->frame_type == TDD) &&
+               (((subframe==1) || (subframe==6))))) { //TDD Subframes 1,6
+
+            if ((prb==((frame_parms->N_RB_DL>>1)-3)) &&
+                (l==pss_symb))
+              skip_half=1;
+            else if ((prb==((frame_parms->N_RB_DL>>1)+3)) &&
+                     (l==pss_symb))
+              skip_half=2;
+          }
+
+
+          prb_off      = 12*prb;
+          prb_off2     = 7+(12*(prb-(frame_parms->N_RB_DL>>1)-1));
+          dl_ch0p      = dl_ch0+(12*prb);
+          dl_ch1p      = dl_ch1+(12*prb);
+
+          if (prb<=(frame_parms->N_RB_DL>>1)){
+            rxF      = &rxdataF[aarx][prb_off+
+                                      frame_parms->first_carrier_offset +
+                                      (symbol*(frame_parms->ofdm_symbol_size))];
+          }
+          else {
+            rxF      = &rxdataF[aarx][prb_off2+
+                                      (symbol*(frame_parms->ofdm_symbol_size))];
+          }
 #ifdef DEBUG_DLSCH_DEMOD
-	  printf("symbol %d / rb %d: alloc %d skip_half %d (rxF %p, rxF_ext %p) prb_off (%d,%d)\n",symbol,prb,rb_alloc_ind,skip_half,rxF,rxF_ext,prb_off,prb_off2);
+          printf("symbol %d / rb %d: alloc %d skip_half %d (rxF %p, rxF_ext %p) prb_off (%d,%d)\n",symbol,prb,rb_alloc_ind,skip_half,rxF,rxF_ext,prb_off,prb_off2);
 #endif
          /* if (mimo_mode <= PUSCH_PRECODING1)
            *pmi_loc = (pmi>>((prb>>2)<<1))&3;
-	  else
-	   *pmi_loc=(pmi>>prb)&1;
+          else
+           *pmi_loc=(pmi>>prb)&1;
          // printf("symbol_mod %d (pilots %d) rb %d, sb %d, pmi %d (pmi_loc %p,rxF %p, ch00 %p, ch01 %p, rxF_ext %p dl_ch0_ext %p dl_ch1_ext %p)\n",symbol_mod,pilots,prb,prb>>2,*pmi_loc,pmi_loc,rxF,dl_ch0, dl_ch1, rxF_ext,dl_ch0_ext,dl_ch1_ext);
 */
-	 *pmi_loc = get_pmi(frame_parms->N_RB_DL,mimo_mode,pmi,prb);
+         *pmi_loc = get_pmi(frame_parms->N_RB_DL,mimo_mode,pmi,prb);
           pmi_loc++;
 
-	  if (prb != (frame_parms->N_RB_DL>>1)) { // This PRB is not around DC
-	    if (pilots==0) {
-	      if (skip_half==1) {
-		memcpy(dl_ch0_ext,dl_ch0p,6*sizeof(int32_t));
-		memcpy(dl_ch1_ext,dl_ch1p,6*sizeof(int32_t));
-		memcpy(rxF_ext,rxF,6*sizeof(int32_t));
+          if (prb != (frame_parms->N_RB_DL>>1)) { // This PRB is not around DC
+            if (pilots==0) {
+              if (skip_half==1) {
+                memcpy(dl_ch0_ext,dl_ch0p,6*sizeof(int32_t));
+                memcpy(dl_ch1_ext,dl_ch1p,6*sizeof(int32_t));
+                memcpy(rxF_ext,rxF,6*sizeof(int32_t));
 #ifdef DEBUG_DLSCH_DEMOD
-		for (i=0;i<6;i++)
-		  printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
+                for (i=0;i<6;i++)
+                  printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
 #endif
-		dl_ch0_ext+=6;
-		dl_ch1_ext+=6;
-		rxF_ext+=6;
-	      } else if (skip_half==2) {
-		memcpy(dl_ch0_ext,dl_ch0p+6,6*sizeof(int32_t));
-		memcpy(dl_ch1_ext,dl_ch1p+6,6*sizeof(int32_t));
-		memcpy(rxF_ext,rxF+6,6*sizeof(int32_t));
+                dl_ch0_ext+=6;
+                dl_ch1_ext+=6;
+                rxF_ext+=6;
+              } else if (skip_half==2) {
+                memcpy(dl_ch0_ext,dl_ch0p+6,6*sizeof(int32_t));
+                memcpy(dl_ch1_ext,dl_ch1p+6,6*sizeof(int32_t));
+                memcpy(rxF_ext,rxF+6,6*sizeof(int32_t));
 #ifdef DEBUG_DLSCH_DEMOD
-		for (i=0;i<6;i++)
-		  printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
+                for (i=0;i<6;i++)
+                  printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
 #endif
-		dl_ch0_ext+=6;
-		dl_ch1_ext+=6;
-		rxF_ext+=6;
-	      } else {  // skip_half==0
-		memcpy(dl_ch0_ext,dl_ch0p,12*sizeof(int32_t));
-		memcpy(dl_ch1_ext,dl_ch1p,12*sizeof(int32_t));
-		memcpy(rxF_ext,rxF,12*sizeof(int32_t));
+                dl_ch0_ext+=6;
+                dl_ch1_ext+=6;
+                rxF_ext+=6;
+              } else {  // skip_half==0
+                memcpy(dl_ch0_ext,dl_ch0p,12*sizeof(int32_t));
+                memcpy(dl_ch1_ext,dl_ch1p,12*sizeof(int32_t));
+                memcpy(rxF_ext,rxF,12*sizeof(int32_t));
 #ifdef DEBUG_DLSCH_DEMOD
-		for (i=0;i<12;i++)
-		  printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
+                for (i=0;i<12;i++)
+                  printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
 #endif
-		dl_ch0_ext+=12;
-		dl_ch1_ext+=12;
-		rxF_ext+=12;
-	      }
-	    } else { // pilots=1
-	      j=0;
-
-	      if (skip_half==1) {
-		for (i=0; i<6; i++) {
-		  if ((i!=frame_parms->nushift) &&
-		      (i!=((frame_parms->nushift+3)%6))) {
-		    rxF_ext[j]=rxF[i];
+                dl_ch0_ext+=12;
+                dl_ch1_ext+=12;
+                rxF_ext+=12;
+              }
+            } else { // pilots=1
+              j=0;
+
+              if (skip_half==1) {
+                for (i=0; i<6; i++) {
+                  if ((i!=frame_parms->nushift) &&
+                      (i!=((frame_parms->nushift+3)%6))) {
+                    rxF_ext[j]=rxF[i];
 #ifdef DEBUG_DLSCH_DEMOD
-		    printf("(pilots,skip1)extract rb %d, re %d (%d)=> (%d,%d)\n",prb,i,j,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                    printf("(pilots,skip1)extract rb %d, re %d (%d)=> (%d,%d)\n",prb,i,j,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
 #endif
-		    dl_ch0_ext[j]=dl_ch0p[i];
-		    dl_ch1_ext[j++]=dl_ch1p[i];
-		  }
-		}
-		dl_ch0_ext+=4;
-		dl_ch1_ext+=4;
-		rxF_ext+=4;
-	      } else if (skip_half==2) {
-		for (i=0; i<6; i++) {
-		  if ((i!=frame_parms->nushift) &&
-		      (i!=((frame_parms->nushift+3)%6))) {
-		    rxF_ext[j]=rxF[(i+6)];
+                    dl_ch0_ext[j]=dl_ch0p[i];
+                    dl_ch1_ext[j++]=dl_ch1p[i];
+                  }
+                }
+                dl_ch0_ext+=4;
+                dl_ch1_ext+=4;
+                rxF_ext+=4;
+              } else if (skip_half==2) {
+                for (i=0; i<6; i++) {
+                  if ((i!=frame_parms->nushift) &&
+                      (i!=((frame_parms->nushift+3)%6))) {
+                    rxF_ext[j]=rxF[(i+6)];
 #ifdef DEBUG_DLSCH_DEMOD
-		    printf("(pilots,skip2)extract rb %d, re %d (%d) => (%d,%d)\n",prb,i,j,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                    printf("(pilots,skip2)extract rb %d, re %d (%d) => (%d,%d)\n",prb,i,j,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
 #endif
-		    dl_ch0_ext[j]=dl_ch0p[i+6];
-		    dl_ch1_ext[j++]=dl_ch1p[i+6];
-		  }
-		}
-		dl_ch0_ext+=4;
-		dl_ch1_ext+=4;
-		rxF_ext+=4;
-
-	      } else { //skip_half==0
-		for (i=0; i<12; i++) {
-		  if ((i!=frame_parms->nushift) &&
-		      (i!=frame_parms->nushift+3) &&
-		      (i!=frame_parms->nushift+6) &&
-		      (i!=((frame_parms->nushift+9)%12))) {
-		    rxF_ext[j]=rxF[i];
+                    dl_ch0_ext[j]=dl_ch0p[i+6];
+                    dl_ch1_ext[j++]=dl_ch1p[i+6];
+                  }
+                }
+                dl_ch0_ext+=4;
+                dl_ch1_ext+=4;
+                rxF_ext+=4;
+
+              } else { //skip_half==0
+                for (i=0; i<12; i++) {
+                  if ((i!=frame_parms->nushift) &&
+                      (i!=frame_parms->nushift+3) &&
+                      (i!=frame_parms->nushift+6) &&
+                      (i!=((frame_parms->nushift+9)%12))) {
+                    rxF_ext[j]=rxF[i];
 #ifdef DEBUG_DLSCH_DEMOD
-		    printf("(pilots)extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                    printf("(pilots)extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
 #endif
-		    dl_ch0_ext[j]  =dl_ch0p[i];
-		    dl_ch1_ext[j++]=dl_ch1p[i];
-		  }
-		}
-		dl_ch0_ext+=8;
-		dl_ch1_ext+=8;
-		rxF_ext+=8;
-	      } //skip_half==0
-	    } //pilots==1
-	  } else {       // Do middle RB (around DC)
-
-	    if (pilots==0) {
-	      memcpy(dl_ch0_ext,dl_ch0p,6*sizeof(int32_t));
-	      memcpy(dl_ch1_ext,dl_ch1p,6*sizeof(int32_t));
-	      memcpy(rxF_ext,rxF,6*sizeof(int32_t));
+                    dl_ch0_ext[j]  =dl_ch0p[i];
+                    dl_ch1_ext[j++]=dl_ch1p[i];
+                  }
+                }
+                dl_ch0_ext+=8;
+                dl_ch1_ext+=8;
+                rxF_ext+=8;
+              } //skip_half==0
+            } //pilots==1
+          } else {       // Do middle RB (around DC)
+
+            if (pilots==0) {
+              memcpy(dl_ch0_ext,dl_ch0p,6*sizeof(int32_t));
+              memcpy(dl_ch1_ext,dl_ch1p,6*sizeof(int32_t));
+              memcpy(rxF_ext,rxF,6*sizeof(int32_t));
 #ifdef DEBUG_DLSCH_DEMOD
-	      for (i=0; i<6; i++) {
-		printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
-	      }
+              for (i=0; i<6; i++) {
+                printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
+              }
 #endif
-	      rxF_ext+=6;
-	      dl_ch0_ext+=6;
-	      dl_ch1_ext+=6;
-	      dl_ch0p+=6;
-	      dl_ch1p+=6;
+              rxF_ext+=6;
+              dl_ch0_ext+=6;
+              dl_ch1_ext+=6;
+              dl_ch0p+=6;
+              dl_ch1p+=6;
 
-	      rxF       = &rxdataF[aarx][1+((symbol*(frame_parms->ofdm_symbol_size)))];
+              rxF       = &rxdataF[aarx][1+((symbol*(frame_parms->ofdm_symbol_size)))];
 
-	      memcpy(dl_ch0_ext,dl_ch0p,6*sizeof(int32_t));
-	      memcpy(dl_ch1_ext,dl_ch1p,6*sizeof(int32_t));
-	      memcpy(rxF_ext,rxF,6*sizeof(int32_t));
+              memcpy(dl_ch0_ext,dl_ch0p,6*sizeof(int32_t));
+              memcpy(dl_ch1_ext,dl_ch1p,6*sizeof(int32_t));
+              memcpy(rxF_ext,rxF,6*sizeof(int32_t));
 #ifdef DEBUG_DLSCH_DEMOD
-	      for (i=0; i<6; i++) {
-		printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
-	      }
+              for (i=0; i<6; i++) {
+                printf("extract rb %d, re %d => (%d,%d)\n",prb,i,*(short *)&rxF_ext[i],*(1+(short*)&rxF_ext[i]));
+              }
 #endif
-	      rxF_ext+=6;
-	      dl_ch0_ext+=6;
-	      dl_ch1_ext+=6;
-	    } else { // pilots==1
-	      j=0;
-
-	      for (i=0; i<6; i++) {
-		if ((i!=frame_parms->nushift) &&
-		    (i!=((frame_parms->nushift+3)%6))) {
-		  dl_ch0_ext[j]=dl_ch0p[i];
-		  dl_ch1_ext[j]=dl_ch1p[i];
-		  rxF_ext[j++]=rxF[i];
+              rxF_ext+=6;
+              dl_ch0_ext+=6;
+              dl_ch1_ext+=6;
+            } else { // pilots==1
+              j=0;
+
+              for (i=0; i<6; i++) {
+                if ((i!=frame_parms->nushift) &&
+                    (i!=((frame_parms->nushift+3)%6))) {
+                  dl_ch0_ext[j]=dl_ch0p[i];
+                  dl_ch1_ext[j]=dl_ch1p[i];
+                  rxF_ext[j++]=rxF[i];
 #ifdef DEBUG_DLSCH_DEMOD
-		  printf("(pilots)extract rb %d, re %d (%d) => (%d,%d)\n",prb,i,j,*(short *)&rxF[i],*(1+(short*)&rxF[i]));
+                  printf("(pilots)extract rb %d, re %d (%d) => (%d,%d)\n",prb,i,j,*(short *)&rxF[i],*(1+(short*)&rxF[i]));
 #endif
-		}
-	      }
-	      rxF       = &rxdataF[aarx][1+symbol*(frame_parms->ofdm_symbol_size)];
-
-	      for (; i<12; i++) {
-		if ((i!=((frame_parms->nushift+6)%12)) &&
-		    (i!=((frame_parms->nushift+9)%12))) {
-		  dl_ch0_ext[j]=dl_ch0p[i];
-		  dl_ch1_ext[j]=dl_ch1p[i];
-		  rxF_ext[j++]=rxF[i-6];
+                }
+              }
+              rxF       = &rxdataF[aarx][1+symbol*(frame_parms->ofdm_symbol_size)];
+
+              for (; i<12; i++) {
+                if ((i!=((frame_parms->nushift+6)%12)) &&
+                    (i!=((frame_parms->nushift+9)%12))) {
+                  dl_ch0_ext[j]=dl_ch0p[i];
+                  dl_ch1_ext[j]=dl_ch1p[i];
+                  rxF_ext[j++]=rxF[i-6];
 #ifdef DEBUG_DLSCH_DEMOD
-		  printf("(pilots)extract rb %d, re %d (%d) => (%d,%d)\n",prb,i,j,*(short *)&rxF[1+i-6],*(1+(short*)&rxF[1+i-6]));
+                  printf("(pilots)extract rb %d, re %d (%d) => (%d,%d)\n",prb,i,j,*(short *)&rxF[1+i-6],*(1+(short*)&rxF[1+i-6]));
 #endif
-		}
-	      }
-
-	      dl_ch0_ext+=8;
-	      dl_ch1_ext+=8;
-	      rxF_ext+=8;
-	    } //pilots==1
-	  }  // if Middle PRB
-	} // if odd PRB
+                }
+              }
+
+              dl_ch0_ext+=8;
+              dl_ch1_ext+=8;
+              rxF_ext+=8;
+            } //pilots==1
+          }  // if Middle PRB
+        } // if odd PRB
       } // if rballoc==1
     } // for prb
   } // for aarx
@@ -4784,7 +4809,7 @@ void print_bytes(char *s,__m128i *x)
   printf("%s  : %d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n",s,
          tempb[0],tempb[1],tempb[2],tempb[3],tempb[4],tempb[5],tempb[6],tempb[7],
          tempb[8],tempb[9],tempb[10],tempb[11],tempb[12],tempb[13],tempb[14],tempb[15]
-	 );
+         );
 
 }
 
diff --git a/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c b/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c
index 4c70f0823075cad3ccc7e81faf56013cc99ee08e..04353aa663ee35e490dfc3da52809623c9d793cf 100644
--- a/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c
+++ b/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c
@@ -156,7 +156,7 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
 
 
   uint8_t *x0 = NULL; //dlsch0_harq->e;
-  MIMO_mode_t mimo_mode = dlsch0_harq->mimo_mode;
+  MIMO_mode_t mimo_mode;//= dlsch0_harq->mimo_mode;
 
   int first_layer0; //= dlsch0_harq->first_layer;
   int Nlayers0; //  = dlsch0_harq->Nlayers;
@@ -1411,8 +1411,13 @@ int dlsch_modulation(int32_t **txdataF,
 
   nsymb = (frame_parms->Ncp==0) ? 14:12;
 
+  if (dlsch0 != NULL){
   amp_rho_a = (int16_t)(((int32_t)amp*dlsch0->sqrt_rho_a)>>13); //amp=512 in  full scale; dlsch0->sqrt_rho_a=8192in Q2.13, 1 in full scale
   amp_rho_b = (int16_t)(((int32_t)amp*dlsch0->sqrt_rho_b)>>13);
+  } else{
+  amp_rho_a = (int16_t)(((int32_t)amp*dlsch1->sqrt_rho_a)>>13);
+  amp_rho_b = (int16_t)(((int32_t)amp*dlsch1->sqrt_rho_b)>>13);
+  }
 
   if (mod_order0 == 4)
     for (i=0; i<4; i++) {
@@ -1445,6 +1450,7 @@ int dlsch_modulation(int32_t **txdataF,
   //  printf("num_pdcch_symbols %d, nsymb %d\n",num_pdcch_symbols,nsymb);
   for (l=num_pdcch_symbols; l<nsymb; l++) {
 
+  if (dlsch0 != NULL ) {
 #ifdef DEBUG_DLSCH_MODULATION
     printf("Generating DLSCH (harq_pid %d,mimo %d, pmi_alloc0 %lx, mod0 %d, mod1 %d, rb_alloc[0] %d) in %d\n",
             harq_pid,
@@ -1455,6 +1461,7 @@ int dlsch_modulation(int32_t **txdataF,
             rb_alloc[0],
             len);
 #endif
+  }
 
     if (frame_parms->Ncp==0) { // normal prefix
       if ((l==4)||(l==11))
@@ -1611,9 +1618,11 @@ int dlsch_modulation(int32_t **txdataF,
         }
       }
 
-      if (dlsch0_harq->Nlayers>1) {
-        msg("Nlayers %d: re_offset %d, symbol %d offset %d\n",dlsch0_harq->Nlayers,re_offset,l,symbol_offset);
-        return(-1);
+     if (dlsch0) {
+        if (dlsch0_harq->Nlayers>1) {
+          msg("Nlayers %d: re_offset %d, symbol %d offset %d\n",dlsch0_harq->Nlayers,re_offset,l,symbol_offset);
+          return(-1);
+        }
       }
 
       if (dlsch1) {
@@ -1639,6 +1648,17 @@ int dlsch_modulation(int32_t **txdataF,
 
       if (rb_alloc_ind > 0) {
         //    printf("Allocated rb %d/symbol %d, skip_half %d, subframe_offset %d, symbol_offset %d, re_offset %d, jj %d\n",rb,l,skip_half,subframe_offset,symbol_offset,re_offset,jj);
+      if (dlsch0 != NULL) {
+        get_pmi_temp = get_pmi(frame_parms->N_RB_DL,
+                               dlsch0->harq_processes[harq_pid]->mimo_mode,
+                               dlsch0->harq_processes[harq_pid]->pmi_alloc,
+                               rb);
+      } else
+        get_pmi_temp = get_pmi(frame_parms->N_RB_DL,
+                               dlsch1->harq_processes[harq_pid]->mimo_mode,
+                               dlsch1->harq_processes[harq_pid]->pmi_alloc,
+                               rb);
+
 
       allocate_REs_in_RB(frame_parms,
                          txdataF,
@@ -1646,11 +1666,11 @@ int dlsch_modulation(int32_t **txdataF,
                          &jj2,
                          re_offset,
                          symbol_offset,
-                         dlsch0->harq_processes[harq_pid],
-                         (dlsch1==NULL) ? NULL : dlsch1->harq_processes[harq_pid],
+                         (dlsch0 == NULL) ? NULL : dlsch0->harq_processes[harq_pid],
+                         (dlsch1 == NULL) ? NULL : dlsch1->harq_processes[harq_pid],
                          pilots,
                          ((pilots) ? amp_rho_b : amp_rho_a),
-                         get_pmi(frame_parms->N_RB_DL,dlsch0->harq_processes[harq_pid]->mimo_mode,dlsch0->harq_processes[harq_pid]->pmi_alloc,rb),
+                         get_pmi_temp,
                          qam_table_s0,
                          qam_table_s1,
                          &re_allocated,
@@ -1672,7 +1692,11 @@ int dlsch_modulation(int32_t **txdataF,
   }
 
 #ifdef DEBUG_DLSCH_MODULATION
-  msg("generate_dlsch : jj = %d,re_allocated = %d (G %d)\n",jj,re_allocated,get_G(frame_parms,dlsch0_harq->nb_rb,dlsch0_harq->rb_alloc,mod_order0,Nl0,2,0,subframe_offset));
+  if (dlsch0 != NULL){
+    msg("generate_dlsch : jj = %d,re_allocated = %d (G %d)\n",jj,re_allocated,get_G(frame_parms,dlsch0_harq->nb_rb,dlsch0_harq->rb_alloc,mod_order0,Nl0,2,0,subframe_offset));
+  }else{
+    msg("generate_dlsch : jj = %d,re_allocated = %d (G %d)\n",jj,re_allocated,get_G(frame_parms,dlsch1_harq->nb_rb,dlsch1_harq->rb_alloc,mod_order1,Nl1,2,0,subframe_offset));
+  }
 #endif
 
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_ENB_DLSCH_MODULATION, VCD_FUNCTION_OUT);
diff --git a/openair1/PHY/LTE_TRANSPORT/power_control.c b/openair1/PHY/LTE_TRANSPORT/power_control.c
index f811f7524bb74c9153e288e5122bab114c585141..bd6b6387f1906dfa0c3c0b25fa2a1029bb9759b2 100644
--- a/openair1/PHY/LTE_TRANSPORT/power_control.c
+++ b/openair1/PHY/LTE_TRANSPORT/power_control.c
@@ -34,9 +34,9 @@
 double ratioPB[2][4]={{ 1.0,4.0/5.0,3.0/5.0,2.0/5.0},
           { 5.0/4.0,1.0,3.0/4.0,1.0/2.0}};
 */
-					  
+
 double ratioPB[2][4]={{ 0.00000,  -0.96910,  -2.21849,  -3.97940}, //in db
-		      { 0.96910,   0.00000,  -1.24939,  -3.01030}};
+                      { 0.96910,   0.00000,  -1.24939,  -3.01030}};
 
 double pa_values[8]={-6.0,-4.77,-3.0,-1.77,0.0,1.0,2.0,3.0}; //reported by higher layers
 
@@ -45,21 +45,21 @@ double get_pa_dB(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated)
   return(pa_values[pdsch_config_dedicated->p_a]);
 }
 
-double computeRhoA_eNB(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated,  
-                       LTE_eNB_DLSCH_t *dlsch_eNB,int dl_power_off, uint8_t n_antenna_port){		    	
+double computeRhoA_eNB(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated,
+                       LTE_eNB_DLSCH_t *dlsch_eNB, int dl_power_off, uint8_t n_antenna_port){
   double rho_a_dB;
   double sqrt_rho_a_lin;
 
   rho_a_dB = pa_values[ pdsch_config_dedicated->p_a];
-	
+
   if(!dl_power_off) //if dl_power_offset is 0, this is for MU-interference, TM5
     rho_a_dB-=10*log10(2);
-  
+
   if(n_antenna_port==4) // see TS 36.213 Section 5.2
     rho_a_dB=+10*log10(2);
-	
-  sqrt_rho_a_lin= pow(10,(0.05*rho_a_dB));	
-	
+
+  sqrt_rho_a_lin= pow(10,(0.05*rho_a_dB));
+
   dlsch_eNB->sqrt_rho_a= (short) (sqrt_rho_a_lin*pow(2,13));
 
 #if DEBUG_PC
@@ -78,9 +78,9 @@ double computeRhoB_eNB(PDSCH_CONFIG_DEDICATED  *pdsch_config_dedicated,
 
   double rho_a_dB, rho_b_dB;
   double sqrt_rho_b_lin;
-	
+
   rho_a_dB= computeRhoA_eNB(pdsch_config_dedicated,dlsch_eNB,dl_power_off, n_antenna_port);
-	
+
   if(n_antenna_port>1)
     rho_b_dB= ratioPB[1][pdsch_config_common->p_b] + rho_a_dB;
   else
@@ -99,24 +99,24 @@ double computeRhoB_eNB(PDSCH_CONFIG_DEDICATED  *pdsch_config_dedicated,
 
 double computeRhoA_UE(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated,
                       LTE_UE_DLSCH_t *dlsch_ue,
-                      unsigned char dl_power_off, 
-		      uint8_t n_antenna_port
- 		    ){		    	
-    
+                      unsigned char dl_power_off,
+                      uint8_t n_antenna_port
+                    ){
+
   double rho_a_dB;
   double sqrt_rho_a_lin;
 
   rho_a_dB = pa_values[ pdsch_config_dedicated->p_a];
-	
-  if(!dl_power_off) 
-    rho_a_dB-=10*log10(2); 
+
+  if(!dl_power_off)
+    rho_a_dB-=10*log10(2);
   //if dl_power_offset is 0, this is for MU-interference, TM5. But in practice UE may assume 16 or 64QAM TM4 as multiuser
-  
+
    if(n_antenna_port==4) // see TS 36.213 Section 5.2
     rho_a_dB=+10*log10(2);
-	
-  sqrt_rho_a_lin= pow(10,(0.05*rho_a_dB));	
-	
+
+  sqrt_rho_a_lin= pow(10,(0.05*rho_a_dB));
+
   dlsch_ue->sqrt_rho_a= (short) (sqrt_rho_a_lin*pow(2,13));
 
 #ifdef DEBUG_PC
@@ -135,9 +135,9 @@ double computeRhoB_UE(PDSCH_CONFIG_DEDICATED  *pdsch_config_dedicated,
 
   double rho_a_dB, rho_b_dB;
   double sqrt_rho_b_lin;
-	
+
   rho_a_dB= computeRhoA_UE(pdsch_config_dedicated,dlsch_ue,dl_power_off, n_antenna_port);
-	
+
   if(n_antenna_port>1)
     rho_b_dB= ratioPB[1][pdsch_config_common->p_b] + rho_a_dB;
   else
diff --git a/openair1/PHY/LTE_TRANSPORT/proto.h b/openair1/PHY/LTE_TRANSPORT/proto.h
index 6a889c5dfb9f87dbc37715db4f1921bb849ebcc3..b4874569ae96282332fc6f9720d68514fdab1521 100644
--- a/openair1/PHY/LTE_TRANSPORT/proto.h
+++ b/openair1/PHY/LTE_TRANSPORT/proto.h
@@ -217,7 +217,7 @@ int32_t dlsch_modulation_SIC(int32_t **sic_buffer,
                          uint8_t num_pdcch_symbols,
                          LTE_eNB_DLSCH_t *dlsch0,
                          LTE_eNB_DLSCH_t *dlsch1,
-			 int G);
+                         int G);
 /*
   \brief This function is the top-level routine for generation of the sub-frame signal (frequency-domain) for MCH.
   @param txdataF Table of pointers for frequency-domain TX signals
@@ -720,15 +720,15 @@ int32_t dlsch_qpsk_llr(LTE_DL_FRAME_PARMS *frame_parms,
 
 int32_t dlsch_qpsk_llr_SIC(LTE_DL_FRAME_PARMS *frame_parms,
                        int **rxdataF_comp,
-		                   int32_t **sic_buffer,
-		                   int **rho_i,
+                                   int32_t **sic_buffer,
+                                   int **rho_i,
                        short *dlsch_llr,
-		                   uint8_t num_pdcch_symbols,
+                                   uint8_t num_pdcch_symbols,
                        uint16_t nb_rb,
                        uint8_t subframe,
-		                   uint32_t rb_alloc,
+                                   uint32_t rb_alloc,
                        uint16_t mod_order_0,
-		                   LTE_UE_DLSCH_t *dlsch0);
+                                   LTE_UE_DLSCH_t *dlsch0);
 
 void dlsch_16qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
                      int32_t **rxdataF_comp,
@@ -753,30 +753,30 @@ void dlsch_16qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
 */
 void dlsch_16qam_llr_SIC (LTE_DL_FRAME_PARMS *frame_parms,
                           int32_t **rxdataF_comp,
-			                    int32_t **sic_buffer,  //Q15
-		                      int32_t **rho_i,
-			                    int16_t *dlsch_llr,
-			                    uint8_t num_pdcch_symbols,
-			                    int32_t **dl_ch_mag,
-			                    uint16_t nb_rb,
-			                    uint8_t subframe,
-			                    uint32_t rb_alloc,
+                                            int32_t **sic_buffer,  //Q15
+                                      int32_t **rho_i,
+                                            int16_t *dlsch_llr,
+                                            uint8_t num_pdcch_symbols,
+                                            int32_t **dl_ch_mag,
+                                            uint16_t nb_rb,
+                                            uint8_t subframe,
+                                            uint32_t rb_alloc,
                           uint16_t mod_order_0,
-			                    LTE_UE_DLSCH_t *dlsch0);
+                                            LTE_UE_DLSCH_t *dlsch0);
 
 void dlsch_64qam_llr_SIC(LTE_DL_FRAME_PARMS *frame_parms,
                          int32_t **rxdataF_comp,
-			                   int32_t **sic_buffer,  //Q15
-		                     int32_t **rho_i,
-			                   int16_t *dlsch_llr,
-			                   uint8_t num_pdcch_symbols,
-			                   int32_t **dl_ch_mag,
-			                   int32_t **dl_ch_magb,
-			                   uint16_t nb_rb,
-			                   uint8_t subframe,
-			                   uint32_t rb_alloc,
+                                           int32_t **sic_buffer,  //Q15
+                                     int32_t **rho_i,
+                                           int16_t *dlsch_llr,
+                                           uint8_t num_pdcch_symbols,
+                                           int32_t **dl_ch_mag,
+                                           int32_t **dl_ch_magb,
+                                           uint16_t nb_rb,
+                                           uint8_t subframe,
+                                           uint32_t rb_alloc,
                          uint16_t mod_order_0,
-			                   LTE_UE_DLSCH_t *dlsch0);
+                                           LTE_UE_DLSCH_t *dlsch0);
 
 
 void dlsch_64qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
@@ -889,12 +889,12 @@ void dlsch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms,
                          uint8_t dual_stream_UE);
 
 void dlsch_detection_mrc_TM34(LTE_DL_FRAME_PARMS *frame_parms,
-			      LTE_UE_PDSCH *lte_ue_pdsch_vars, 
-			      int harq_pid,
-			      int round,
-			      unsigned char symbol,
-			      unsigned short nb_rb,
-			      unsigned char dual_stream_UE);
+                              LTE_UE_PDSCH *lte_ue_pdsch_vars,
+                              int harq_pid,
+                              int round,
+                              unsigned char symbol,
+                              unsigned short nb_rb,
+                              unsigned char dual_stream_UE);
 
 /** \fn dlsch_extract_rbs_single(int32_t **rxdataF,
     int32_t **dl_ch_estimates,
@@ -966,8 +966,8 @@ uint16_t dlsch_extract_rbs_dual(int32_t **rxdataF,
                                 uint8_t symbol,
                                 uint8_t subframe,
                                 uint32_t high_speed_flag,
-                                LTE_DL_FRAME_PARMS *frame_parms, 
-				MIMO_mode_t mimo_mode);
+                                LTE_DL_FRAME_PARMS *frame_parms,
+                                MIMO_mode_t mimo_mode);
 
 /** \brief This function performs channel compensation (matched filtering) on the received RBs for this allocation.  In addition, it computes the squared-magnitude of the channel with weightings for 16QAM/64QAM detection as well as dual-stream detection (cross-correlation)
     @param rxdataF_ext Frequency-domain received signal in RBs to be demodulated
@@ -1013,7 +1013,7 @@ void dlsch_dual_stream_correlationTM34(LTE_DL_FRAME_PARMS *frame_parms,
                                    int **dl_ch_estimates_ext_i,
                                    int **dl_ch_rho_ext,
                                    unsigned char output_shift0,
-				   unsigned char output_shift1);
+                                   unsigned char output_shift1);
 
 void dlsch_channel_compensation_TM56(int **rxdataF_ext,
                                      int **dl_ch_estimates_ext,
@@ -1032,18 +1032,18 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
 
 
 void dlsch_channel_compensation_TM34(LTE_DL_FRAME_PARMS *frame_parms,
-				    LTE_UE_PDSCH *lte_ue_pdsch_vars,
-				    PHY_MEASUREMENTS *phy_measurements,
-				    int eNB_id,
-				    unsigned char symbol,
-				    unsigned char mod_order0,
-				    unsigned char mod_order1,
-				    int harq_pid,
-				    int round,
-				    MIMO_mode_t mimo_mode,
-				    unsigned short nb_rb,
-				    unsigned char output_shift0,
-				    unsigned char output_shift1);
+                                    LTE_UE_PDSCH *lte_ue_pdsch_vars,
+                                    PHY_MEASUREMENTS *phy_measurements,
+                                    int eNB_id,
+                                    unsigned char symbol,
+                                    unsigned char mod_order0,
+                                    unsigned char mod_order1,
+                                    int harq_pid,
+                                    int round,
+                                    MIMO_mode_t mimo_mode,
+                                    unsigned short nb_rb,
+                                    unsigned char output_shift0,
+                                    unsigned char output_shift1);
 
 
 /** \brief This function computes the average channel level over all allocated RBs and antennas (TX/RX) in order to compute output shift for compensated signal
@@ -1061,13 +1061,13 @@ void dlsch_channel_level(int32_t **dl_ch_estimates_ext,
 
 
 void dlsch_channel_level_TM34(int **dl_ch_estimates_ext,
-			      LTE_DL_FRAME_PARMS *frame_parms,
-			      unsigned char *pmi_ext,
-			      int *avg_0,
-			      int *avg_1,
-			      uint8_t symbol,
-			      unsigned short nb_rb,
-			      MIMO_mode_t mimo_mode);
+                              LTE_DL_FRAME_PARMS *frame_parms,
+                              unsigned char *pmi_ext,
+                              int *avg_0,
+                              int *avg_1,
+                              uint8_t symbol,
+                              unsigned short nb_rb,
+                              MIMO_mode_t mimo_mode);
 
 
 void dlsch_channel_level_TM56(int32_t **dl_ch_estimates_ext,
@@ -1121,7 +1121,7 @@ uint32_t dlsch_decoding_emul(PHY_VARS_UE *phy_vars_ue,
     - RE extraction (pilot, PBCH, synch. signals)
     - antenna combining (MRC, Alamouti, cycling)
     - LLR computation
-    This function supports TM1, 2, 3, 5, and 6. 
+    This function supports TM1, 2, 3, 5, and 6.
     @param phy_vars_ue Pointer to PHY variables
     @param type Type of PDSCH (SI_PDSCH,RA_PDSCH,PDSCH,PMCH)
     @param eNB_id eNb index (Nid1) 0,1,2
@@ -1129,19 +1129,19 @@ uint32_t dlsch_decoding_emul(PHY_VARS_UE *phy_vars_ue,
     @param subframe Subframe number
     @param symbol Symbol on which to act (within sub-frame)
     @param first_symbol_flag set to 1 on first DLSCH symbol
-    @param rx_type. rx_type=RX_IC_single_stream will enable interference cancellation of a second stream when decoding the first stream. In case of TM1, 2, 5, and this can cancel interference from a neighbouring cell given by eNB_id_i. In case of TM5, eNB_id_i should be set to n_connected_eNB to perform multi-user interference cancellation. In case of TM3, eNB_id_i should be set to eNB_id to perform co-channel interference cancellation; this option should be used together with an interference cancellation step [...]. In case of TM3, if rx_type=RX_IC_dual_stream, both streams will be decoded by applying the IC single stream receiver twice.  
+    @param rx_type. rx_type=RX_IC_single_stream will enable interference cancellation of a second stream when decoding the first stream. In case of TM1, 2, 5, and this can cancel interference from a neighbouring cell given by eNB_id_i. In case of TM5, eNB_id_i should be set to n_connected_eNB to perform multi-user interference cancellation. In case of TM3, eNB_id_i should be set to eNB_id to perform co-channel interference cancellation; this option should be used together with an interference cancellation step [...]. In case of TM3, if rx_type=RX_IC_dual_stream, both streams will be decoded by applying the IC single stream receiver twice.
     @param i_mod Modulation order of the interfering stream
 */
 int32_t rx_pdsch(PHY_VARS_UE *phy_vars_ue,
-	     PDSCH_t type,
-	     uint8_t eNB_id,
-	     uint8_t eNB_id_i,
-	     uint8_t subframe,
-	     uint8_t symbol,
-	     uint8_t first_symbol_flag,
-	     RX_type_t rx_type,
-	     uint8_t i_mod,
-	     uint8_t harq_pid);
+             PDSCH_t type,
+             uint8_t eNB_id,
+             uint8_t eNB_id_i,
+             uint8_t subframe,
+             uint8_t symbol,
+             uint8_t first_symbol_flag,
+             RX_type_t rx_type,
+             uint8_t i_mod,
+             uint8_t harq_pid);
 
 int32_t rx_pdcch(LTE_UE_COMMON *lte_ue_common_vars,
                  LTE_UE_PDCCH **lte_ue_pdcch_vars,
@@ -1322,7 +1322,7 @@ uint32_t get_TBS_UL(uint8_t mcs, uint16_t nb_rb);
 */
 uint32_t get_prb(int N_RB_DL,int odd_slot,int vrb,int Ngap);
 
-/* \brief Return prb for a given vrb index 
+/* \brief Return prb for a given vrb index
    @param vrb_type VRB type (0=localized,1=distributed)
    @param rb_alloc_dci rballoc field from DCI
 */
@@ -1437,7 +1437,7 @@ uint8_t subframe2harq_pid(LTE_DL_FRAME_PARMS *frame_parms,frame_t frame,uint8_t
 uint8_t subframe2harq_pid_eNBrx(LTE_DL_FRAME_PARMS *frame_parms,uint8_t subframe);
 
 int generate_ue_dlsch_params_from_dci(int frame,
-				      uint8_t subframe,
+                                      uint8_t subframe,
                                       void *dci_pdu,
                                       rnti_t rnti,
                                       DCI_format_t dci_format,
@@ -1676,7 +1676,7 @@ uint16_t computeRIV(uint16_t N_RB_DL,uint16_t RBstart,uint16_t Lcrbs);
 
 /** \brief  This routine expands a single (wideband) PMI to subband PMI bitmap similar to the one used in the UCI and in the dlsch_modulation routine
     @param frame_parms Pointer to DL frame configuration parameters
-    @param wideband_pmi (0,1,2,3 for rank 0 and 0,1 for rank 1) 
+    @param wideband_pmi (0,1,2,3 for rank 0 and 0,1 for rank 1)
     @param rank (0 or 1)
     @returns subband PMI bitmap
 */
@@ -1684,7 +1684,7 @@ uint32_t pmi_extend(LTE_DL_FRAME_PARMS *frame_parms,uint8_t wideband_pmi, uint8_
 
 /** \brief  This routine extracts a single subband PMI from a bitmap coming from UCI or the pmi_extend function
     @param N_RB_DL number of resource blocks
-    @param mimo_mode  
+    @param mimo_mode
     @param pmi_alloc subband PMI bitmap
     @param rb resource block for which to extract PMI
     @returns subband PMI
@@ -1692,11 +1692,11 @@ uint32_t pmi_extend(LTE_DL_FRAME_PARMS *frame_parms,uint8_t wideband_pmi, uint8_
 uint8_t get_pmi(uint8_t N_RB_DL,MIMO_mode_t mode, uint32_t pmi_alloc,uint16_t rb);
 
 int get_nCCE_offset_l1(int *CCE_table,
-		       const unsigned char L, 
-		       const int nCCE, 
-		       const int common_dci, 
-		       const unsigned short rnti, 
-		       const unsigned char subframe);
+                       const unsigned char L,
+                       const int nCCE,
+                       const int common_dci,
+                       const unsigned short rnti,
+                       const unsigned char subframe);
 
 uint16_t get_nCCE(uint8_t num_pdcch_symbols,LTE_DL_FRAME_PARMS *frame_parms,uint8_t mi);
 
@@ -1758,22 +1758,22 @@ void generate_pucch_emul(PHY_VARS_UE *phy_vars_ue,
 
 
 uint32_t rx_pucch(PHY_VARS_eNB *phy_vars_eNB,
-		  PUCCH_FMT_t fmt,
-		  uint8_t UE_id,
-		  uint16_t n1_pucch,
-		  uint16_t n2_pucch,
-		  uint8_t shortened_format,
-		  uint8_t *payload,
-		  int     frame,
-		  uint8_t subframe,
-		  uint8_t pucch1_thres);
+                  PUCCH_FMT_t fmt,
+                  uint8_t UE_id,
+                  uint16_t n1_pucch,
+                  uint16_t n2_pucch,
+                  uint8_t shortened_format,
+                  uint8_t *payload,
+                  int     frame,
+                  uint8_t subframe,
+                  uint8_t pucch1_thres);
 
 int32_t rx_pucch_emul(PHY_VARS_eNB *phy_vars_eNB,
-		       uint8_t UE_index,
-		       PUCCH_FMT_t fmt,
-		       uint8_t n1_pucch_sel,
-		       uint8_t *payload,
-		       uint8_t subframe);
+                       uint8_t UE_index,
+                       PUCCH_FMT_t fmt,
+                       uint8_t n1_pucch_sel,
+                       uint8_t *payload,
+                       uint8_t subframe);
 
 
 /*!
@@ -1865,18 +1865,19 @@ double get_pa_dB(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated);
 
 double computeRhoA_eNB(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated,
                        LTE_eNB_DLSCH_t *dlsch_eNB,
-		       int dl_power_off, 
-		       uint8_t n_antenna_port);
+                       int dl_power_off,
+                       uint8_t n_antenna_port);
 
 double computeRhoB_eNB(PDSCH_CONFIG_DEDICATED  *pdsch_config_dedicated,
                        PDSCH_CONFIG_COMMON *pdsch_config_common,
                        uint8_t n_antenna_port,
-                       LTE_eNB_DLSCH_t *dlsch_eNB,int dl_power_off);
+                       LTE_eNB_DLSCH_t *dlsch_eNB,
+                       int dl_power_off);
 
 double computeRhoA_UE(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated,
                       LTE_UE_DLSCH_t *dlsch_ue,
                       uint8_t dl_power_off,
-		      uint8_t n_antenna_port);
+                      uint8_t n_antenna_port);
 
 double computeRhoB_UE(PDSCH_CONFIG_DEDICATED  *pdsch_config_dedicated,
                       PDSCH_CONFIG_COMMON *pdsch_config_common,
@@ -1890,7 +1891,7 @@ double computeRhoB_UE(PDSCH_CONFIG_DEDICATED  *pdsch_config_dedicated,
   LTE_UE_DLSCH_t *dlsch_ue);
 */
 
-uint8_t get_prach_prb_offset(LTE_DL_FRAME_PARMS *frame_parms, uint8_t tdd_mapindex, uint16_t Nf); 
+uint8_t get_prach_prb_offset(LTE_DL_FRAME_PARMS *frame_parms, uint8_t tdd_mapindex, uint16_t Nf);
 
 uint8_t ul_subframe2pdcch_alloc_subframe(LTE_DL_FRAME_PARMS *frame_parms,uint8_t n);
 
diff --git a/openair1/PHY/defs.h b/openair1/PHY/defs.h
index 9d941d3bd60c1e8326533cd1e2415ec5efea980c..529f6297715969730c12936f46be31aa11545371 100755
--- a/openair1/PHY/defs.h
+++ b/openair1/PHY/defs.h
@@ -387,7 +387,7 @@ typedef struct PHY_VARS_eNB_s {
 #ifdef LOCALIZATION
   /// time state for localization
   time_stats_t localization_stats;
-#endif 
+#endif
 
   int32_t pucch1_stats_cnt[NUMBER_OF_UE_MAX][10];
   int32_t pucch1_stats[NUMBER_OF_UE_MAX][10*1024];
diff --git a/openair1/PHY/impl_defs_lte.h b/openair1/PHY/impl_defs_lte.h
index e1736c9c9a123d8cf2eca6b27cca9b4914669055..b47f95d27035599355f89e3eebbbf3211ae57b15 100755
--- a/openair1/PHY/impl_defs_lte.h
+++ b/openair1/PHY/impl_defs_lte.h
@@ -793,7 +793,7 @@ typedef struct {
   /// - first index: ? [0..7] (hard coded) accessed via \c harq_pid
   /// - second index: ? [0..7] (hard coded) accessed via \c round
   /// - third index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
-  /// - fourth index: ? [0..168*N_RB_DL[ 
+  /// - fourth index: ? [0..168*N_RB_DL[
   int32_t **rxdataF_comp1[8][8];
   /// \brief Downlink channel estimates extracted in PRBS.
   /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
diff --git a/openair1/SIMULATION/LTE_PHY/dlsim.c b/openair1/SIMULATION/LTE_PHY/dlsim.c
index 0b39a3580a3c7813a6daa776338f42bccc23ead4..e7408ac06a6cacfeee6fb31c3d91f5d884dcf0d5 100755
--- a/openair1/SIMULATION/LTE_PHY/dlsim.c
+++ b/openair1/SIMULATION/LTE_PHY/dlsim.c
@@ -38,6 +38,9 @@
  \warning
 */
 
+//#define DEBUG_HARQ
+//#define PRINT_THROUGHPUT
+
 #include <string.h>
 #include <math.h>
 #include <unistd.h>
@@ -163,6 +166,7 @@ int main(int argc, char **argv)
   int n_users = 1;
   int TB=0;
   RX_type_t rx_type=rx_standard;
+  unsigned char  cur_harq_pid;
 
 
   SCM_t channel_model=Rayleigh1;
@@ -262,6 +266,7 @@ int main(int argc, char **argv)
   double thr_cw0_tm4 = 0.0;
   double thr_cw0_tm4_nonconst = 0.0;
   double thr_cw0[4]={0,0,0,0}, thr_cw1[4]={0,0,0,0}, thr_cw0_tot = 0.0, thr_cw1_tot = 0.0;
+  double tbs0_init=0.0, tbs1_init=0.0, rate0_init=0.0, rate1_init=0.0;
   char channel_model_input[17]="I";
 
   int TB0_active = 1;
@@ -597,7 +602,7 @@ int main(int argc, char **argv)
       printf("-o Sample offset for receiver\n");
       printf("-s Starting SNR, runs from SNR to SNR+%.1fdB in steps of %.1fdB. If n_frames is 1 then just SNR is simulated and MATLAB/OCTAVE output is generated\n", snr_int, snr_step);
       printf("-f step size of SNR, default value is 1.\n");
-      printf("-r ressource block allocation (see  section 7.1.6.3 in 36.213\n");
+      printf("-r resource block allocation (see  section 7.1.6.3 in 36.213\n");
       printf("-g Channel model, possible values are 3GPP 25.814 SCM-A/B/C/D('A','B','C','D'), 36-101 EPA('E'), EVA ('F'),ETU('G'), Rayghleigh8 ('H'), Rayleigh1('I'), Rayleigh1_corr('J'), Rayleigh1_anticorr('K'), Rice8('L'), Rice1('M'), AWGN('N'), Rayleigh1_orthogonal('P'), Rayleigh1_orth_eff_ch_TM4_prec_real ('Q'), Rayleigh1_orth_eff_ch_TM4_prec_imag ('R'), Rayleigh8_orth_eff_ch_TM4_prec_real ('S'),Rayleigh8_orth_eff_ch_TM4_prec_imag ('T')   \n");
       printf("-F forgetting factor (0 new channel every trial, 1 channel constant\n");
       printf("-x Transmission mode (1,2,6 for the moment)\n");
@@ -607,7 +612,7 @@ int main(int argc, char **argv)
       printf("-R Number of HARQ rounds (fixed)\n");
       printf("-A Turns on calibration mode for abstraction.\n");
       printf("-N Determines the number of Channel Realizations in Abstraction mode. Default value is 1. \n");
-      printf("-O Set the percenatge of effective rate to testbench the modem performance (typically 30 and 70, range 1-100) \n");
+      printf("-O Set the percentage of effective rate to testbench the modem performance (typically 30 and 70, range 1-100) \n");
       printf("-I Input filename for TrCH data (binary)\n");
       printf("-u Receiver type: 0=standard, 1 = single stream IC (for TM3,4,5,6), 2 = dual stream IC (for TM3,4), 3 = SIC (for TM3,4) \n");
       exit(1);
@@ -736,22 +741,26 @@ int main(int argc, char **argv)
     sprintf(bler_fname,"bler_tx%d_rec%d_chan%d_nrx%d_mcs%d_mcsi%d_u%d_imod%d.csv",transmission_mode,rx_type,channel_model,n_rx,mcs1,mcs_i,rx_type,i_mod);
   else if (abstx == 1)
     if (perfect_ce==1)
-   sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_mcs%d_mcsi%d_ab_pce_sh%d_pnort_r45.csv",transmission_mode,rx_type,channel_model,n_frames, n_rx,mcs1, mcs2,interf_unaw_shift );
+   sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_rnd%d_mcs%d_mcsi%d_ab_pce_sh%d_rpmi4.csv",transmission_mode,rx_type,channel_model,n_frames, n_rx, num_rounds, mcs1, mcs2,interf_unaw_shift );
     else
-      sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_mcs%d_mcsi%d_ab_sh%d_pnort_r45.csv",transmission_mode,rx_type,channel_model, n_frames, n_rx,mcs1, mcs2,interf_unaw_shift );
+      sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_rnd%d_mcs%d_mcsi%d_ab_sh%d_rtpmi4.csv",transmission_mode,rx_type,channel_model, n_frames, n_rx, num_rounds, mcs1, mcs2,interf_unaw_shift );
   else //abstx=0
     if (perfect_ce==1)
-      sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_mcs%d_mcsi%d_pce_sh%d_pnort_r45.csv",transmission_mode,rx_type,channel_model,n_frames, n_rx,mcs1, mcs2, interf_unaw_shift);
+      sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_rnd%d_mcs%d_mcsi%d_pce_sh%d_rtpmi4.csv",transmission_mode,rx_type,channel_model,n_frames, n_rx, num_rounds, mcs1, mcs2, interf_unaw_shift);
    else
-    sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_mcs%d_mcsi%d_sh%d_pnort_r45.csv",transmission_mode,rx_type,channel_model,n_frames,n_rx,mcs1, mcs2, interf_unaw_shift);
+    sprintf(bler_fname,"bler_tx%d_r%d_ch%d_%d_nrx%d_rnd%d_mcs%d_mcsi%d_sh%d_pnort_rtpmi4.csv",transmission_mode,rx_type,channel_model,n_frames,n_rx, num_rounds, mcs1, mcs2, interf_unaw_shift);
 
   bler_fd = fopen(bler_fname,"w");
   if (bler_fd==NULL) {
     fprintf(stderr,"Cannot create file %s!\n",bler_fname);
     exit(-1);
   }
+  if ((transmission_mode != 3) && (transmission_mode != 4))
+    fprintf(bler_fd,"SNR; MCS1; MCS2; TBS1; TBS2; rate 0; rate 1; err0_st1; err0_st2 trials0; err1_st1; err1_st2; trials1; err2_st1; err2_st2; trials2; err3_st1; err3_st2; trials3; throug 0; throug 1; sum throug; dci_err\n");
+  else
+    fprintf(bler_fd,"SNR; MCS1; MCS2; TBS1; TBS2; rate 0; rate 1; err0_st1; err0_st2; trials0 r0; trials1 r0; err1_st1; err1_st2; trials0_r1; trials1_r1;; err2_st1; err2_st2; trials0_r2; trials1_r2; err3_st1; err3_st2; trials0_r3; trials1_r3; th0_r0; th1_r0; th_sum_r0; th0_r1; th1_r1; th_sum_r1; th0_r2; th1_r2; th_sum_r2; th0_r3; th1_r3; th_sum_r3; tot_th\n");
+
 
-  fprintf(bler_fd,"SNR; MCS1; MCS2; TBS1; TBS2; rate 0; rate 1; err0_st1; err0_st2 trials0; err1_st1; err1_st2; trials1; err2_st1; err2_st2; trials2; err3_st1; err3_st2; trials3; throug 0; throug 1; sum throug; dci_err\n");
   if (test_perf != 0) {
 
     char hostname[1024];
@@ -791,104 +800,6 @@ int main(int argc, char **argv)
     }
   }
 
-  /*
-  //sprintf(tikz_fname, "second_bler_tx%d_u2=%d_mcs%d_chan%d_nsimus%d.tex",transmission_mode,dual_stream_UE,mcs,channel_model,n_frames);
-  sprintf(tikz_fname, "second_bler_tx%d_u2%d_mcs%d_chan%d_nsimus%d",transmission_mode,dual_stream_UE,mcs,channel_model,n_frames);
-  tikz_fd = fopesprintf(csv_fname,"dataout_tx%d_mcs%d_mcs_interf%d_chan%d_nsimus%d_R%d_abstr_old_perf_ce_llr.m",transmission_mode,mcs1,mcs2,channel_model,n_frames,num_rounds);
-n(tikz_fname,"w");
-  //fprintf(tikz_fd,"\\addplot[color=red, mark=o] plot coordinates {");
-  switch (mcs)
-    {
-    case 0:
-      fprintf(tikz_fd,"\\addplot[color=blue, mark=star] plot coordinates {");
-      break;
-    case 1:
-      fprintf(tikz_fd,"\\addplot[color=red, mark=star] plot coordinates {");
-      break;
-    case 2:
-      fprintf(tikz_fd,"\\addplot[color=green, mark=star] plot coordinates {");
-      break;
-    case 3:
-      fprintf(tikz_fd,"\\addplot[color=yellow, mark=star] plot coordinates {");
-      break;
-    case 4:
-      fprintf(tikz_fd,"\\addplot[color=black, mark=star] plot coordinates {");
-      break;
-    case 5:
-      fprintf(tikz_fd,"\\addplot[color=blue, mark=o] plot coordinates {");
-      break;
-    case 6:
-      fprintf(tikz_fd,"\\addplot[color=red, mark=o] plot coordinates {");
-      break;
-    case 7:
-      fprintf(tikz_fd,"\\addplot[color=green, mark=o] plot coordinates {");
-      break;
-    case 8:
-      fprintf(tikz_fd,"\\addplot[color=yellow, mark=o] plot coordinates {");
-      break;
-    case 9:
-      fprintf(tikz_fd,"\\addplot[color=black, mark=o] plot coordinates {");
-      break;
-    case 10:
-      fprintf(tikz_fd,"\\addplot[color=blue, mark=square] plot coordinates {");
-      break;
-    case 11:
-      fprintf(tikz_fd,"\\addplot[color=red, mark=square] plot coordinates {");
-      break;
-    case 12:
-      fprintf(tikz_fd,"\\addplot[color=green, mark=square] plot coordinates {");
-      break;
-    case 13:
-      fprintf(tikz_fd,"\\addplot[color=yellow, mark=square] plot coordinates {");
-      break;
-    case 14:
-      fprintf(tikz_fd,"\\addplot[color=black, mark=square] plot coordinates {");
-      break;
-    case 15:
-      fprintf(tikz_fd,"\\addplot[color=blue, mark=diamond] plot coordinates {");
-      break;
-    case 16:
-      fprintf(tikz_fd,"\\addplot[color=red, mark=diamond] plot coordinates {");
-      break;
-    case 17:
-      fprintf(tikz_fd,"\\addplot[color=green, mark=diamond] plot coordinates {");
-      break;
-    case 18:
-      fprintf(tikz_fd,"\\addplot[color=yellow, mark=diamond] plot coordinates {");
-      break;
-    case 19:
-      fprintf(tikz_fd,"\\addplot[color=black, mark=diamond] plot coordinates {");
-      break;
-    case 20:
-      fprintf(tikz_fd,"\\addplot[color=blue, mark=x] plot coordinates {");
-      break;
-    case 21:
-      fprintf(tikz_fd,"\\addplot[color=red, mark=x] plot coordinates {");
-      break;
-    case 22:
-      fprintf(tikz_fd,"\\addplot[color=green, mark=x] plot coordinates {");
-      break;
-    case 23:
-      fprintf(tikz_fd,"\\addplot[color=yellow, mark=x] plot coordinates {");
-      break;
-    case 24:
-      fprintf(tikz_fd,"\\addplot[color=black, mark=x] plot coordinates {");
-      break;
-    case 25:
-      fprintf(tikz_fd,"\\addplot[color=blue, mark=x] plot coordinates {");
-      break;
-    case 26:
-      fprintf(tikz_fd,"\\addplot[color=red, mark=+] plot coordinates {");
-      break;
-    case 27:
-      fprintf(tikz_fd,"\\addplot[color=green, mark=+] plot coordinates {");
-      break;
-    case 28:
-      fprintf(tikz_fd,"\\addplot[color=yellow, mark=+] plot coordinates {");
-      break;
-    }
-  */
-
   for (i=0; i<2; i++) {
     s_re[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
     s_im[i] = malloc(FRAME_LENGTH_COMPLEX_SAMPLES*sizeof(double));
@@ -1048,15 +959,6 @@ n(tikz_fname,"w");
   }
 
   if (input_fd==NULL) {
-    /*
-    // common DCI
-    memcpy(&dci_alloc[num_dci].dci_pdu[0],&CCCH_alloc_pdu,sizeof(DCI1A_5MHz_TDD_1_6_t));
-    dci_alloc[num_dci].dci_length = sizeof_DCI1A_5MHz_TDD_1_6_t;
-    dci_alloc[num_dci].L          = 2;
-    dci_alloc[num_dci].rnti       = SI_RNTI;
-    num_dci++;
-    num_common_dci++;
-    */
 
     // UE specific DCI
     for(k=0; k<n_users; k++) {
@@ -2132,10 +2034,16 @@ n(tikz_fname,"w");
       //printf("Trial %d\n",trials);
         fflush(stdout);
         round = 0;
+#ifdef DEBUG_HARQ
+        printf("[DLSIM] TRIAL %d\n", trials);
+#endif
 
         for (i=0; i<frame_parms->nb_antennas_tx; i++) {
           memset(sic_buffer[i], 0, FRAME_LENGTH_COMPLEX_SAMPLES_NO_PREFIX*sizeof(int32_t));
         }
+         //PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->codeword],
+        //memset(PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[0], 0, (8*((3*8*6144)+12))*sizeof(int16_t));
+        //memset(PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[1], 0, (8*((3*8*6144)+12))*sizeof(int16_t));
         //if (trials%100==0)
         eNB2UE[0]->first_run = 1;
 
@@ -2144,20 +2052,33 @@ n(tikz_fname,"w");
 
         resend_cw0_cw1=1;
         resend_cw1=0;
+        TB0_active=1;
 
         while (((transmission_mode == 3 || transmission_mode == 4) &&
-               ((round < num_rounds) && (ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations) &&
-               (ret[1] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations))) ||
+               ((round < num_rounds) && ((ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations) ||
+               (ret[1] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations)))) ||
                ((transmission_mode!=4 && transmission_mode != 3) && ((round< num_rounds) &&
                (ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations)))) {
+#ifdef DEBUG_HARQ
+        printf("\n [DLSIM] On top round is %d\n", round);
+#endif
 
-          //printf("Trial %d, round %d , ret[0] %d, ret[1] %d, round_trials %d\n",trials,round, ret[0], ret[1], round_trials[round]);
 
-        if (ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations)
           round_trials[0][round]++;
+          round_trials[1][round]++;
 
-        if (ret[1] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations)
+          //printf("Trial %d, round %d , ret[0] %d, ret[1] %d, round_trials %d\n",trials,round, ret[0], ret[1], round_trials[round]);
+
+        /*if (ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations) {
+          round_trials[0][round]++;
           round_trials[1][round]++;
+        } else if ((ret[1] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations) && (ret[0] <= PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations))
+          round_trials[1][round]++;*/
+
+
+#ifdef DEBUG_HARQ
+        printf("[DLSIM] Just after while loop TB0 status %d round %d\n", TB0_active, round);
+#endif
 
         // printf("Trial %d, round %d , ret[0] %d, ret[1] %d, round_trials TB0 = %d, round_trials TB1 = %d \n",trials,round, ret[0], ret[1], round_trials[0][round], round_trials[1][round]);
 
@@ -2200,6 +2121,8 @@ n(tikz_fname,"w");
               if (transmission_mode == 3 || transmission_mode == 4)
                   PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->rvidx = round&3;
 
+                //printf("TB0 status %d round %d \n ", TB0_active, round);
+
               if (round == 0) {   // First round
                 TB0_active = 1;
 
@@ -2303,6 +2226,7 @@ n(tikz_fname,"w");
                     break;
 
                   case 5:
+                  case 6:
                     DLSCH_alloc_pdu2_1E[0].ndi             = trials&1;
                     DLSCH_alloc_pdu2_1E[0].rv              = 0;
                     memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu2_1E[0],sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t));
@@ -2401,6 +2325,7 @@ n(tikz_fname,"w");
                     }
                     break;
                   case 5:
+                  case 6:
                     DLSCH_alloc_pdu2_1E[0].ndi             = trials&1;
                     DLSCH_alloc_pdu2_1E[0].rv              = 0;
                     memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu2_1E[0],sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t));
@@ -2512,7 +2437,7 @@ n(tikz_fname,"w");
                         ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       else {  // deactivate TB0
-                        ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi             = 2;
+                        ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi             = 0;
                         ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
                         ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
                         ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
@@ -2528,14 +2453,29 @@ n(tikz_fname,"w");
                         ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       else {  // deactivate TB0
-                        printf("\n Requesting only TB1 from temp DCI\n");
-                        ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 2;
+#ifdef DEBUG_HARQ
+                        printf("\n[DLSIM] Requesting only TB1 from temp DCI\n");
+#endif
+                        ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 4;
                         ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
                         ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
                         ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
                         ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu_1[0],sizeof(DCI2_5MHz_2A_TDD_t));
+                      generate_eNB_dlsch_params_from_dci(0,
+                                                         subframe,
+                                                         &DLSCH_alloc_pdu_1[0],
+                                                         n_rnti+k,
+                                                         format2,
+                                                         PHY_vars_eNB->dlsch_eNB[0],
+                                                         &PHY_vars_eNB->lte_frame_parms,
+                                                         PHY_vars_eNB->pdsch_config_dedicated,
+                                                         SI_RNTI,
+                                                         0,
+                                                         P_RNTI,
+                                                         PHY_vars_eNB->eNB_UE_stats[0].DL_pmi_single);
+
                       break;
                     case 50:
                       if (TB0_active==1) {
@@ -2545,7 +2485,7 @@ n(tikz_fname,"w");
                         ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       else {  // deactivate TB0
-                        ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 2;
+                        ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 0;
                         ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
                         ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
                         ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
@@ -2561,7 +2501,7 @@ n(tikz_fname,"w");
                         ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       else {  // deactivate TB0
-                        ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 2;
+                        ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 0;
                         ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
                         ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
                         ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
@@ -2573,6 +2513,7 @@ n(tikz_fname,"w");
                     break;
 
                   case 5:
+                  case 6:
                     DLSCH_alloc_pdu2_1E[0].ndi             = trials&1;
                     DLSCH_alloc_pdu2_1E[0].rv              = round&3;
                     memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu2_1E[0],sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t));
@@ -2696,14 +2637,28 @@ n(tikz_fname,"w");
                         ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       else {  // deactivate TB0
-                        printf("\n Requesting only TB1 from temp DCI\n");
-                        ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 2;
+#ifdef DEBUG_HARQ
+                        printf("\n [DLSIM] Requesting only TB1 from temp DCI\n");
+#endif
+                        ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 4;
                         ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
                         ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
                         ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
                         ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu_1[0],sizeof(DCI2_5MHz_2A_FDD_t));
+                      generate_eNB_dlsch_params_from_dci(0,
+                                                         subframe,
+                                                         &DLSCH_alloc_pdu_1[0],
+                                                         n_rnti+k,
+                                                         format2,
+                                                         PHY_vars_eNB->dlsch_eNB[0],
+                                                         &PHY_vars_eNB->lte_frame_parms,
+                                                         PHY_vars_eNB->pdsch_config_dedicated,
+                                                         SI_RNTI,
+                                                         0,
+                                                         P_RNTI,
+                                                         PHY_vars_eNB->eNB_UE_stats[0].DL_pmi_single);
                       break;
                     case 50:
                       if (TB0_active==1) {
@@ -2713,7 +2668,7 @@ n(tikz_fname,"w");
                         ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       else {  // deactivate TB0
-                        ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 2;
+                        ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 0;
                         ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
                         ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
                         ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
@@ -2729,7 +2684,7 @@ n(tikz_fname,"w");
                         ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
                       }
                       else {  // deactivate TB0
-                        ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 2;
+                        ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->tpmi             = 0;
                         ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
                         ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
                         ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
@@ -2742,6 +2697,7 @@ n(tikz_fname,"w");
 
 
                   case 5:
+                  case 6:
                     DLSCH_alloc_pdu2_1E[0].ndi             = trials&1;
                     DLSCH_alloc_pdu2_1E[0].rv              = round&3;
                     memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu2_1E[0],sizeof(DCI1E_5MHz_2A_M10PRB_TDD_t));
@@ -2764,10 +2720,18 @@ n(tikz_fname,"w");
               exit(-1);
             }
 
- for (k=0;k<n_users;k++) {
+            for (k=0;k<n_users;k++) {
               for (int TB=0; TB<Kmimo; TB++) {
-                if (PHY_vars_eNB->dlsch_eNB[0][TB] == NULL)
-                  continue;
+                if (TB0_active == 0){
+#ifdef DEBUG_HARQ
+                  printf("[DLSIM ENC] Skip TB0 \n");
+#endif
+                  TB++;
+
+                }
+#ifdef DEBUG_HARQ
+            printf("[DLSIM ENC] process TB %d \n", TB);
+#endif
 
                 coded_bits_per_codeword[TB] = get_G(&PHY_vars_eNB->lte_frame_parms,
                                                 PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->nb_rb,
@@ -2776,8 +2740,6 @@ n(tikz_fname,"w");
                                                 PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->Nl,
                                                 num_pdcch_symbols,
                                                 0,subframe);
-
-
       #ifdef TBS_FIX   // This is for MESH operation!!!
                 tbs[TB] = (double)3*TBStable[get_I_TBS(PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->mcs)][PHY_vars_eNB->dlsch_eNB[k][TB]->nb_rb-1]/4;
       #else
@@ -2842,7 +2804,7 @@ n(tikz_fname,"w");
                                  subframe<<1);
                 stop_meas(&PHY_vars_eNB->dlsch_scrambling_stats);
 
-                if (n_frames==1) {
+                if (n_frames==2) {
                   for (s=0;s<PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->C;s++) {
                     if (s<PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->Cminus)
                       Kr = PHY_vars_eNB->dlsch_eNB[k][TB]->harq_processes[0]->Kminus;
@@ -2859,11 +2821,19 @@ n(tikz_fname,"w");
                                               subframe,
                                               &PHY_vars_eNB->lte_frame_parms,
                                               num_pdcch_symbols,
-                                              PHY_vars_eNB->dlsch_eNB[k][0],
+                                              ((TB0_active == 1)? PHY_vars_eNB->dlsch_eNB[k][0]: NULL),
                                               PHY_vars_eNB->dlsch_eNB[k][1]);
               stop_meas(&PHY_vars_eNB->dlsch_modulation_stats);
             } //n_users
 
+
+                if (((transmission_mode == 3) || (transmission_mode == 4)) && (SNR == snr0) && (trials == 0) && (round == 0)){
+                  rate0_init = rate[0];
+                  rate1_init = rate[1];
+                  tbs0_init=tbs[0];
+                  tbs1_init=tbs[1];
+                }
+
             generate_pilots(PHY_vars_eNB,
                             PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id],
                             AMP,
@@ -2889,7 +2859,7 @@ n(tikz_fname,"w");
                           (subframe*2)+2,
                           &PHY_vars_eNB->lte_frame_parms);
 
-            if (n_frames==1) {
+            if (n_frames==2) {
               write_output("txsigF0.m","txsF0", &PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id][0][subframe*nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size],nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size,1,1);
               if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx>1)
                 write_output("txsigF1.m","txsF1", &PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id][1][subframe*nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size],nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size,1,1);
@@ -2903,7 +2873,7 @@ n(tikz_fname,"w");
             }
             tx_lev_dB = (unsigned int) dB_fixed(tx_lev);
 
-            if (n_frames==1) {
+            if (n_frames==2) {
               write_output("txsigF0.m","txsF0", &PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id][0][subframe*nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size],nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size,1,1);
               if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx>1)
                 write_output("txsigF1.m","txsF1", &PHY_vars_eNB->lte_eNB_common_vars.txdataF[eNB_id][1][subframe*nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size],nsymb*PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size,1,1);
@@ -2917,7 +2887,7 @@ n(tikz_fname,"w");
             }
             tx_lev_dB = (unsigned int) dB_fixed(tx_lev);
 
-            if (n_frames==1) {
+            if (n_frames==2) {
               printf("tx_lev = %d (%d dB)\n",tx_lev,tx_lev_dB);
               write_output("txsig0.m","txs0", &PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][0][subframe* PHY_vars_eNB->lte_frame_parms.samples_per_tti], PHY_vars_eNB->lte_frame_parms.samples_per_tti,1,1);
             }
@@ -3061,7 +3031,7 @@ n(tikz_fname,"w");
         // This is the SNR on the PDSCH for OFDM symbols without pilots -> rho_A
         sigma2_dB = 10*log10((double)tx_lev) +10*log10((double)PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size/(double)(NB_RB*12)) - SNR - get_pa_dB(PHY_vars_eNB->pdsch_config_dedicated);
         sigma2 = pow(10,sigma2_dB/10);
-        if (n_frames==1)
+        if (n_frames==2)
           printf("Sigma2 %f (sigma2_dB %f,%f,%f )\n",sigma2,sigma2_dB,10*log10((double)PHY_vars_eNB->lte_frame_parms.ofdm_symbol_size/(double)(NB_RB*12)),get_pa_dB(PHY_vars_eNB->pdsch_config_dedicated));
 
         for (i=0; i<2*frame_parms->samples_per_tti; i++) {
@@ -3094,7 +3064,7 @@ n(tikz_fname,"w");
           fclose(rx_frame_file);
         */
 
-        if (n_frames==1) {
+        if (n_frames==2) {
           printf("RX level in null symbol %d\n",dB_fixed(signal_energy(&PHY_vars_UE->lte_ue_common_vars.rxdata[0][160+OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES],OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2)));
           printf("RX level in data symbol %d\n",dB_fixed(signal_energy(&PHY_vars_UE->lte_ue_common_vars.rxdata[0][160+(2*OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES)],OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2)));
           printf("rx_level Null symbol %f\n",10*log10(signal_energy_fp(r_re,r_im,1,OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES/2,256+(OFDM_SYMBOL_SIZE_COMPLEX_SAMPLES))));
@@ -3116,7 +3086,7 @@ n(tikz_fname,"w");
         // Inner receiver scheduling for 3 slots
           for (Ns=(2*subframe);Ns<((2*subframe)+3);Ns++) {
             for (l=0;l<pilot2;l++) {
-              if (n_frames==1)
+              if (n_frames==2)
           printf("Ns %d, l %d, l2 %d\n",Ns, l, l+(Ns%2)*pilot2);
               /*
           This function implements the OFDM front end processor (FEP).
@@ -3213,6 +3183,7 @@ n(tikz_fname,"w");
                     pmi_feedback = 0;
                     hold_channel = 1;
                     //printf ("trial %d pmi_feedback %d \n", trials, pmi_feedback);
+                    //printf ("go to PMI feedback\n");
                     goto PMI_FEEDBACK;
                   }
                 }
@@ -3251,7 +3222,7 @@ n(tikz_fname,"w");
                       round=5; // this is meant to stop the "while" loop if DCI is wrong;
                       errs[0][0]++;
 
-                      if (n_frames==1)
+                      if (n_frames==2)
                         printf("DCI error trial %d errs[0][0] %d\n",trials,errs[0][0]);
                     }
                   }
@@ -3309,7 +3280,7 @@ n(tikz_fname,"w");
                           errs[0][0]++;
                           round=5;
 
-                          if (n_frames==1)
+                          if (n_frames==2)
                             printf("DCI misdetection trial %d\n",trials);
 
                         }
@@ -3389,9 +3360,14 @@ n(tikz_fname,"w");
               }
 
               if (dlsch_active == 1) {
+                if (TB0_active==1)
+                  cur_harq_pid =PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid;
+                else
+                  cur_harq_pid =PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid;
+
                 if ((Ns==(1+(2*subframe))) && (l==0)) {// process PDSCH symbols 1,2,3,4,5,(6 Normal Prefix
                   if (transmission_mode == 5) {
-                    if ((PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid]->dl_power_off==0) &&
+                    if ((PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[cur_harq_pid]->dl_power_off==0) &&
                         (openair_daq_vars.use_ia_receiver ==1)) {
                       rx_type = rx_IC_single_stream;
                     } else {
@@ -3403,6 +3379,7 @@ n(tikz_fname,"w");
                   start_meas(&PHY_vars_UE->dlsch_llr_stats);
 
                   for (m=PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols; m<pilot2; m++) {
+
                     if (rx_pdsch(PHY_vars_UE,
                                  PDSCH,
                                  eNB_id,
@@ -3412,7 +3389,7 @@ n(tikz_fname,"w");
                                  (m==PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols)?1:0,
                                  rx_type,
                                  i_mod,
-                                 PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid)==-1){
+                                 cur_harq_pid)==-1){
                       dlsch_active = 0;
                       break;
                     }
@@ -3432,7 +3409,7 @@ n(tikz_fname,"w");
                              0,
                              rx_type,
                              i_mod,
-                             PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid)==-1){
+                             cur_harq_pid)==-1){
                         dlsch_active=0;
                         break;
                         }
@@ -3452,7 +3429,7 @@ n(tikz_fname,"w");
                                  0,
                                  rx_type,
                                  i_mod,
-                                 PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid)==-1) {
+                                 cur_harq_pid)==-1) {
                     dlsch_active=0;
                     break;
                     }
@@ -3485,8 +3462,22 @@ n(tikz_fname,"w");
 
           for (TB=0; TB<Kmimo; TB++){ // may be we ll have to swap CW
 
-            if (PHY_vars_UE->dlsch_ue[0][TB] == NULL)
-            continue;
+           /* if (PHY_vars_UE->dlsch_ue[0][TB] == NULL){
+              printf("[DLSIM] PHY_vars_UE->dlsch_ue[0][TB] == NULL\n");
+              printf("HERE HERE HERE HERE\n");
+              continue;
+            }*/
+
+              if (TB0_active == 0){
+#ifdef DEBUG_HARQ
+              printf("[DLSIM] Skip TB0 \n");
+#endif
+              TB++;
+
+            }
+#ifdef DEBUG_HARQ
+            printf("[DLSIM] process TB %d \n", TB);
+#endif
 
             PHY_vars_UE->dlsch_ue[0][TB]->rnti = (common_flag==0) ? n_rnti: SI_RNTI;
             coded_bits_per_codeword[TB] = get_G(&PHY_vars_eNB->lte_frame_parms,
@@ -3500,7 +3491,7 @@ n(tikz_fname,"w");
             PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid]->G = coded_bits_per_codeword[TB];
             PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid]->Qm = get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->mcs);
 
-            if (n_frames==1) {
+            if (n_frames==2) {
               printf("Kmimo=%d, TB=%d, G=%d, TBS=%d\n",Kmimo,TB,coded_bits_per_codeword[TB],
                      PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid]->TBS);
 
@@ -3551,21 +3542,27 @@ n(tikz_fname,"w");
 
             start_meas(&PHY_vars_UE->dlsch_decoding_stats);
             ret[TB] = dlsch_decoding(PHY_vars_UE,
-                                             PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[TB],
-                                             &PHY_vars_UE->lte_frame_parms,
-                                             PHY_vars_UE->dlsch_ue[0][TB],
-                                             PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid],
-                                             subframe,
-                                             PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid,
-                                             1,llr8_flag);
+                                     PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid]->codeword],
+                                     &PHY_vars_UE->lte_frame_parms,
+                                     PHY_vars_UE->dlsch_ue[0][TB],
+                                     PHY_vars_UE->dlsch_ue[0][TB]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid],
+                                    subframe,
+                                    PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid,
+                                    1,llr8_flag);
             stop_meas(&PHY_vars_UE->dlsch_decoding_stats);
+#ifdef DEBUG_HARQ
+            printf("[DLSIM] ret[%d] = %d\n", TB, ret[TB]);
+#endif
+
             //printf("retr cw 0 = %d\n", ret[0]);
             //printf("current round = %d\n", PHY_vars_UE->dlsch_ue[0][cw_non_sic]->harq_processes[PHY_vars_UE->dlsch_ue[0][cw_non_sic]->current_harq_pid]->round);
 
 
 
             if (ret[TB] <= PHY_vars_UE->dlsch_ue[0][TB]->max_turbo_iterations ) { //if CW0 is decoded, approach CW1
-
+#ifdef DEBUG_HARQ
+            printf("[DLSIM] TB%d is decoded\n", TB);
+#endif
 
                 /*avg_iter[TB] += ret[TB];
                 iter_trials[TB]++;*/
@@ -3690,8 +3687,11 @@ n(tikz_fname,"w");
               }
 
               if ((PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) &&
-                  (PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode <=DUALSTREAM_PUSCH_PRECODING) &&
-                  rx_type==rx_SIC_dual_stream) {
+                  (PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode <=DUALSTREAM_PUSCH_PRECODING) && (TB0_active == 1) &&
+                  (rx_type==rx_SIC_dual_stream)) {
+#ifdef DEBUG_HARQ
+                printf("[DLSIM] Starting SIC procedure\n");
+#endif
                // printf("current round = %d\n", PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->round);
 
 
@@ -3699,10 +3699,14 @@ n(tikz_fname,"w");
               //printf("\n ret[TB0] = %d  round %d\n", ret[TB], round);
 
                 for (round_sic = 0 ; round_sic < (round +1); round_sic++) {
+
+#ifdef DEBUG_HARQ
+                printf("[DLSIM] 0 Round sic = %d\n", round_sic);
+#endif
                 //printf("I enter round_sic loop \n");
                 //printf("round_sic= %d\n", round_sic);
-                dlsch0_ue_harq = PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid];
-                dlsch0_eNB_harq = PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid];
+                dlsch0_ue_harq = PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][1]->current_harq_pid];
+                dlsch0_eNB_harq = PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][1]->current_harq_pid];
 
                 dlsch0_eNB_harq->mimo_mode    = PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode;
                 dlsch0_eNB_harq->rb_alloc[0]  = dlsch0_ue_harq->rb_alloc_even[0];
@@ -3730,7 +3734,7 @@ n(tikz_fname,"w");
                                &PHY_vars_UE->dlsch_interleaving_stats);
 
 
-                coded_bits_per_codeword[TB]= get_G(&PHY_vars_UE->lte_frame_parms,
+                coded_bits_per_codeword[0]= get_G(&PHY_vars_UE->lte_frame_parms,
                                                 PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_eNB[eNB_id]->current_harq_pid]->nb_rb,
                                                 PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_eNB[eNB_id]->current_harq_pid]->rb_alloc,
                                                 get_Qm(PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_eNB[eNB_id]->current_harq_pid]->mcs),
@@ -3752,38 +3756,39 @@ n(tikz_fname,"w");
                                                     num_pdcch_symbols,
                                                     &PHY_vars_UE->dlsch_eNB[0][0],
                                                     NULL,
-                                                    coded_bits_per_codeword[TB]);
+                                                    coded_bits_per_codeword[0]);
 
                // write_output("sic_buffer.m","sic", *sic_buffer,re_allocated,1,1);
                // write_output("rxdataF_comp1.m","rxF_comp1", *PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round],14*12*25,1,1);
                // write_output("rxdataF_rho.m","rho", *PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round],14*12*25,1,1);
 
-                switch  (get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->mcs)){
+                switch  (get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)){
+
 
                   case 2:
 
                     dlsch_qpsk_llr_SIC(&PHY_vars_UE->lte_frame_parms,
-                                       PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
+                                       PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
                                        sic_buffer,
-                                       PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
-                                       PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword],
+                                       PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
+                                       PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->codeword],
                                        num_pdcch_symbols,
                                        dlsch0_eNB_harq->nb_rb,
                                        subframe,
                                        dlsch0_eNB_harq->rb_alloc[0],
-                                       get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->mcs),
-                                       PHY_vars_UE->dlsch_ue[eNB_id][TB]);
+                                       get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs),
+                                       PHY_vars_UE->dlsch_ue[eNB_id][0]);
                   break;
 
                   case 4:
 
                     dlsch_16qam_llr_SIC(&PHY_vars_UE->lte_frame_parms,
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
                                         sic_buffer,
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->codeword],
                                         num_pdcch_symbols,
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
                                         dlsch0_eNB_harq->nb_rb,
                                         subframe,
                                         dlsch0_eNB_harq->rb_alloc[0],
@@ -3792,67 +3797,70 @@ n(tikz_fname,"w");
                   break;
                   case 6:
                     dlsch_64qam_llr_SIC(&PHY_vars_UE->lte_frame_parms,
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
                                         sic_buffer,
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->codeword],
                                         num_pdcch_symbols,
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_magb1[PHY_vars_UE->dlsch_ue[0][TB]->current_harq_pid][round_sic],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_magb1[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid][round_sic],
                                         dlsch0_eNB_harq->nb_rb,
                                         subframe,
                                         dlsch0_eNB_harq->rb_alloc[0],
-                                        get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB]->harq_processes[0]->mcs),
+                                        get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs),
                                         PHY_vars_UE->dlsch_ue[eNB_id][TB]);
                   break;
                     }
-                  }
+                  //}// rouns sic
+#ifdef DEBUG_HARQ
+                  printf("[DLSIM] TB1 is mapped into CW%d\n", PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->codeword);
+#endif
 
                     //  write_output("rxdata_llr1.m","llr1", PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[1],re_allocated*2,1,0);
 
                   // replace cw_sic with TB+1
-                  PHY_vars_UE->dlsch_ue[0][TB+1]->rnti = (common_flag==0) ? n_rnti: SI_RNTI;
-                  coded_bits_per_codeword[TB+1]= get_G(&PHY_vars_eNB->lte_frame_parms,
-                                                         PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->nb_rb,
-                                                         PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->rb_alloc,
-                                                         get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->mcs),
-                                                         PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->Nl,
+                  PHY_vars_UE->dlsch_ue[0][1]->rnti = (common_flag==0) ? n_rnti: SI_RNTI;
+                  coded_bits_per_codeword[1]= get_G(&PHY_vars_eNB->lte_frame_parms,
+                                                         PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->nb_rb,
+                                                         PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->rb_alloc,
+                                                         get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs),
+                                                         PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->Nl,
                                                          num_pdcch_symbols,
                                                          0,
                                                          subframe);
 
-                  PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->G = coded_bits_per_codeword[TB+1];
-                  PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->Qm = get_Qm(PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->mcs);
+                  PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->G = coded_bits_per_codeword[1];
+                  PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->Qm = get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs);
 
-                  if (n_frames==1) {
-                    printf("Kmimo=%d, cw=%d, G=%d, TBS=%d\n",Kmimo,TB+1,coded_bits_per_codeword[TB+1],
-                    PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->TBS);
+                  if (n_frames==2) {
+                    printf("Kmimo=%d, cw=%d, G=%d, TBS=%d\n",Kmimo,1,coded_bits_per_codeword[1],
+                    PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->TBS);
 
                   // calculate uncoded BER
-                    uncoded_ber_bit = (short*) malloc(sizeof(short)*coded_bits_per_codeword[TB+1]);
+                    uncoded_ber_bit = (short*) malloc(sizeof(short)*coded_bits_per_codeword[1]);
                     AssertFatal(uncoded_ber_bit, "uncoded_ber_bit==NULL");
-                    sprintf(fname,"dlsch%d_rxF_r%d_cw%d_llr.m",eNB_id,round, TB+1);
-                    sprintf(vname,"dl%d_r%d_cw%d_llr",eNB_id,round, TB+1);
-                    write_output(fname,vname, PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[TB+1],coded_bits_per_codeword[TB+1],1,0);
-                    sprintf(fname,"dlsch_cw%d_e.m", TB+1);
-                    sprintf(vname,"dlschcw%d_e", TB+1);
-                    write_output(fname, vname,PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->e,coded_bits_per_codeword[TB+1],1,4);
+                    sprintf(fname,"dlsch%d_rxF_r%d_cw%d_llr.m",eNB_id,round,1);
+                    sprintf(vname,"dl%d_r%d_cw%d_llr",eNB_id,round, 1);
+                    write_output(fname,vname, PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[1],coded_bits_per_codeword[1],1,0);
+                    sprintf(fname,"dlsch_cw%d_e.m", 1);
+                    sprintf(vname,"dlschcw%d_e", 1);
+                    write_output(fname, vname,PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->e,coded_bits_per_codeword[1],1,4);
                     uncoded_ber=0;
                     printf("trials=%d\n", trials);
-                    for (i=0;i<coded_bits_per_codeword[TB+1];i++)
-                    if (PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->e[i] != (PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword][i]<0)) {
+                    for (i=0;i<coded_bits_per_codeword[1];i++)
+                    if (PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->e[i] != (PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->codeword][i]<0)) {
                       uncoded_ber_bit[i] = 1;
                       uncoded_ber++;
                     }
                     else
                     uncoded_ber_bit[i] = 0;
 
-                   uncoded_ber/=coded_bits_per_codeword[TB+1];
+                   uncoded_ber/=coded_bits_per_codeword[1];
                    avg_ber += uncoded_ber;
-                   sprintf(fname,"cw%d_uncoded_ber_bit.m", TB+1);
-                   sprintf(vname,"uncoded_ber_bit_cw%d", TB+1);
-                   write_output(fname, vname,uncoded_ber_bit,coded_bits_per_codeword[TB+1],1,0);
-                   printf("cw %d, uncoded ber %f\n",TB+1,uncoded_ber);
+                   sprintf(fname,"cw%d_uncoded_ber_bit.m", 1);
+                   sprintf(vname,"uncoded_ber_bit_cw%d", 1);
+                   write_output(fname, vname,uncoded_ber_bit,coded_bits_per_codeword[1],1,0);
+                   printf("cw %d, uncoded ber %f\n",1,uncoded_ber);
                          free(uncoded_ber_bit);
                    uncoded_ber_bit = NULL;
                 }
@@ -3860,84 +3868,102 @@ n(tikz_fname,"w");
                 start_meas(&PHY_vars_UE->dlsch_unscrambling_stats);
                 dlsch_unscrambling(&PHY_vars_UE->lte_frame_parms,
                                    0,
-                                   PHY_vars_UE->dlsch_ue[0][TB+1],
-                                   coded_bits_per_codeword[TB+1],
-                                   PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword],
-                                   TB+1,
+                                   PHY_vars_UE->dlsch_ue[0][1],
+                                   coded_bits_per_codeword[1],
+                                   PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->codeword],
+                                   1,
                                    subframe<<1);
                 stop_meas(&PHY_vars_UE->dlsch_unscrambling_stats);
 
                 start_meas(&PHY_vars_UE->dlsch_decoding_stats);
                 ret[1] = dlsch_decoding(PHY_vars_UE,
-                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid]->codeword],
+                                        PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->codeword],
                                         &PHY_vars_UE->lte_frame_parms,
-                                        PHY_vars_UE->dlsch_ue[0][TB+1],
-                                        PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid],
+                                        PHY_vars_UE->dlsch_ue[0][1],
+                                        PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid],
                                         subframe,
-                                        PHY_vars_UE->dlsch_ue[0][TB+1]->current_harq_pid,
+                                        PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid,
                                         1,llr8_flag);
                 stop_meas(&PHY_vars_UE->dlsch_decoding_stats);
 
-                //printf("ret TB 1 = %d round %d \n", ret[1], round);
+#ifdef DEBUG_HARQ
+                printf("[DLSIM] Decoding TB1 in SIC: ret[1] = %d,  round sic %d\n", ret[1], round_sic);
+#endif
 
-                if (ret[TB+1] <= PHY_vars_UE->dlsch_ue[0][TB+1]->max_turbo_iterations ) {
+                //printf("ret TB 1 = %d round %d \n", ret[1], round);
 
-                  avg_iter[TB+1] += ret[TB+1];
-                  iter_trials[TB+1]++;
+                if (ret[1] <= PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations ) {
+                  round_sic = round+1; // to exit round_sic
+#ifdef DEBUG_HARQ
+                  printf("[DLSIM] TB1 is decoded in SIC loop\n");
+#endif
+                  avg_iter[1] += ret[1];
+                  iter_trials[1]++;
 
 
-                  if (n_frames==1) {
-                    printf("cw sic %d, round %d: No DLSCH errors found, uncoded ber %f\n",TB+1,round,uncoded_ber);
+                  if (n_frames==2) {
+                    printf("cw sic %d, round %d: No DLSCH errors found, uncoded ber %f\n",1,round,uncoded_ber);
 
                     #ifdef PRINT_BYTES
-                    for (s=0;s<PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->C;s++) {
-                    if (s<PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->Cminus)
-                      Kr = PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->Kminus;
+                    for (s=0;s<PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->C;s++) {
+                    if (s<PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->Cminus)
+                      Kr = PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->Kminus;
                     else
-                      Kr = PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->Kplus;
+                      Kr = PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->Kplus;
 
                     Kr_bytes = Kr>>3;
 
                     printf("Decoded_output (Segment %d):\n",s);
 
                     for (i=0;i<Kr_bytes;i++)
-                      printf("%d : %x (%x)\n",i,PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->c[s][i],
-                      PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->c[s][i]);
+                      printf("%d : %x (%x)\n",i,PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->c[s][i],
+                      PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->c[s][i]);
                     }
                     #endif
                   }
-                } else{
-                  errs[TB+1][round]++;
+                }
+              } //round_sic
+
+
+            if (ret[1] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations ){
+              errs[1][round]++;
+#ifdef DEBUG_HARQ
+                  printf("[DLSIM] TB1 is not decoded in SIC loop, errs[TB1][round %d] = %d\n",round, errs[1][round]);
+#endif
+
                  // exit(0);
 
-                  avg_iter[TB+1] += ret[TB+1]-1;
-                  iter_trials[TB+1]++;
+                  avg_iter[1] += ret[1]-1;
+                  iter_trials[1]++;
 
-                  if (n_frames==1) {
+                  if (n_frames==2) {
                     //if ((n_frames==1) || (SNR>=30)) {
-                    printf("cw sic %d, round %d: DLSCH errors found, uncoded ber %f\n",TB+1,round,uncoded_ber);
+                    printf("cw sic %d, round %d: DLSCH errors found, uncoded ber %f\n",1,round,uncoded_ber);
 #ifdef PRINT_BYTES
-                    for (s=0;s<PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->C;s++) {
-                      if (s<PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->Cminus)
-                        Kr = PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->Kminus;
+                    for (s=0;s<PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->C;s++) {
+                      if (s<PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->Cminus)
+                        Kr = PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->Kminus;
                       else
-                        Kr = PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->Kplus;
+                        Kr = PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->Kplus;
 
                       Kr_bytes = Kr>>3;
 
                       printf("Decoded_output (Segment %d):\n",s);
                       for (i=0;i<Kr_bytes;i++)
-                        printf("%d : %x (%x)\n",i,PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->c[s][i],
-                         PHY_vars_UE->dlsch_ue[0][TB+1]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][TB+1]->harq_processes[0]->c[s][i]);
+                        printf("%d : %x (%x)\n",i,PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->c[s][i],
+                         PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->c[s][i]);
                     }
 #endif
                   } //n_frames==1
                  // exit(0);
-              } //if (ret > PHY_vars_UE->dlsch_ue[0][TB+1]->max_turbo_iterations )
+              } //if (ret > PHY_vars_UE->dlsch_ue[0][1]->max_turbo_iterations )
             }//if SIC
           } else {
 
             errs[TB][round]++;
+#ifdef DEBUG_HARQ
+            printf("[DLSIM] TB%d is not decoded outside SIC loop, errs[TB%d][round %d] = %d\n", TB, TB, round, errs[TB][round]);
+#endif
 
 
               /*if (cw_non_sic==0) {
@@ -3947,17 +3973,21 @@ n(tikz_fname,"w");
 
             if ((PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) &&
               (PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode <=DUALSTREAM_PUSCH_PRECODING) &&
-                (rx_type==rx_SIC_dual_stream)) {
-                errs[TB+1][round]++;
+                (rx_type==rx_SIC_dual_stream) && (TB0_active ==1)) {
+                errs[1][round]++;
+#ifdef DEBUG_HARQ
+              printf("[DLSIM] HERE OR NOT TB%d is not decoded outside SIC loop, errs[TB%d][round %d] = %d\n", 1, 1, round, errs[1][round]);
+#endif
               }
 
+
                 /*if (cw_non_sic==1) {
           avg_iter[1] += ret[1]-1;
           iter_trials[1]++;
               }*/
 
 
-              if (n_frames==1) {
+              if (n_frames==2) {
           //if ((n_frames==1) || (SNR>=30)) {
                 printf("cw %d, round %d: DLSCH errors found, uncoded ber %f\n",TB,round,uncoded_ber);
 #ifdef PRINT_BYTES
@@ -3982,7 +4012,7 @@ n(tikz_fname,"w");
 
           stop_meas(&PHY_vars_UE->phy_proc_rx);
 
-          if (n_frames==1) {
+          if (n_frames==2) {
 
             //rxsig
             sprintf(fname,"rxsig0_r%d.m",round);
@@ -4068,10 +4098,11 @@ n(tikz_fname,"w");
              0,// UE_id
              subframe);
           }
+#ifdef DEBUG_HARQ
+          printf("[DLSIM] Errors errs[TB0][round %d] = %d, errs[TB1][round %d] = %d\n ", round, errs[0][round], round, errs[1][round]);
+#endif
 
-
-
-          if ((transmission_mode != 3 && transmission_mode !=4 ) && ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations){
+          if ((transmission_mode != 3) && (transmission_mode !=4) && (ret[0] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations)){
             //printf("flag 1 \n");
             round++;
           }
@@ -4083,20 +4114,23 @@ n(tikz_fname,"w");
             resend_cw0_cw1=1;  //resend both cws
             resend_cw1=0;
             TB0_active=1;
-            //printf("flag 2 \n");
 
           }
 
           if ((transmission_mode == 3 || transmission_mode == 4 ) && (ret[1] > PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations ) && (ret[0] <= PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations)){
             resend_one[round]++;
-            round++;
             resend_cw0_cw1=0;
             TB0_active=0;
-            //PHY_vars_UE->PHY_measurements.rank[eNB_id]=0;
-           // printf("\n DLSIM TB0 disactivated\n");
-            //printf("flag 3 \n");
-
+#ifdef DEBUG_HARQ
+            printf("[DLSIM] ret[TB0] =%d, ret[TB1] =%d, trial %d \n", ret[0], ret[1], trials);
+            printf("[DLSIM] TB0 deactivated\n");
+#endif
+            round++;
           }
+#ifdef DEBUG_HARQ
+          printf("[DLSIM] Now round is %d, trial %d\n" , round, trials);
+#endif
+
 
         }
 
@@ -4265,21 +4299,31 @@ n(tikz_fname,"w");
 
       if (transmission_mode == 3 || transmission_mode == 4) {
         // FOR CW0
-        thr_cw0[0] = rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)*(1-((double)errs[0][0]/(double)round_trials[0][0]));
-        thr_cw0[1] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/2)*(((double)errs[0][0] - (double)errs[0][1])/(double)round_trials[0][0]);
-        thr_cw0[2] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/3)*(((double)errs[0][1] - (double)errs[0][2])/(double)round_trials[0][0]);
-        thr_cw0[3] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/4)*(((double)errs[0][2] - (double)errs[0][3])/(double)round_trials[0][0]);
+        thr_cw0[0] = rate0_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)*(1-((double)errs[0][0]/(double)round_trials[0][0]));
+        thr_cw0[1] = (rate0_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/2)*(((double)errs[0][0] - (double)errs[0][1])/(double)round_trials[0][0]);
+        thr_cw0[2] = (rate0_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/3)*(((double)errs[0][1] - (double)errs[0][2])/(double)round_trials[0][0]);
+        thr_cw0[3] = (rate0_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)/4)*(((double)errs[0][2] - (double)errs[0][3])/(double)round_trials[0][0]);
         thr_cw0_tot = (double)thr_cw0[0]+(double)thr_cw0[1]+(double)thr_cw0[2]+(double)thr_cw0[3];
-        printf("\n Throughput cw0 sum =  %f \n", thr_cw0_tot);
+#ifdef PRINT_THROUGHPUT
+        printf("rate  %f \n", rate0_init);
+        printf("rate*mod_order  %f \n", rate0_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs));
+        printf("Probability  %f \n", (1-((double)errs[0][0]/(double)round_trials[0][0])));
+        printf("Throughput cw0 sum =  %f \n", thr_cw0_tot);
+        printf("Throughput cw0 round 0 =  %f \n", thr_cw0[0]);
+        printf("Throughput cw0 round 1 =  %f \n", thr_cw0[1]);
+        printf("Throughput cw0 round 2 =  %f \n", thr_cw0[2]);
+        printf("Throughput cw0 round 3 =  %f \n", thr_cw0[3]);
         printf("round_trials =  %d, errs[0][0] = %d, round_trials[0][1] = %d, errs[0][1] = %d, round_trials[0][2] = %d, errs[0][2] = %d, \
         round_trials[0][3] = %d, errs[0][3] = %d \n", round_trials[0][0], errs[0][0],round_trials[0][1], errs[0][1], round_trials[0][2], \
         errs[0][2], round_trials[0][3], errs[0][3]);
+#endif
 
-        thr_cw1[0] = rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)*(1-((double)errs[1][0]/(double)round_trials[1][0]));
-        thr_cw1[1] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)/2)*(((double)errs[1][0] - (double)errs[1][1])/(double)round_trials[1][0]);
-        thr_cw1[2] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)/3)*(((double)errs[1][1] - (double)errs[1][2])/(double)round_trials[1][0]);
-        thr_cw1[3] = (rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)/4)*(((double)errs[1][2] - (double)errs[1][3])/(double)round_trials[1][0]);
+        thr_cw1[0] = rate1_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)*(1-((double)errs[1][0]/(double)round_trials[1][0]));
+        thr_cw1[1] = (rate1_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)/2)*(((double)errs[1][0] - (double)errs[1][1])/(double)round_trials[1][0]);
+        thr_cw1[2] = (rate1_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)/3)*(((double)errs[1][1] - (double)errs[1][2])/(double)round_trials[1][0]);
+        thr_cw1[3] = (rate1_init*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)/4)*(((double)errs[1][2] - (double)errs[1][3])/(double)round_trials[1][0]);
         thr_cw1_tot = (double)thr_cw1[0]+(double)thr_cw1[1]+(double)thr_cw1[2]+(double)thr_cw1[3];
+#ifdef PRINT_THROUGHPUT
         printf("Throughput cw1 sum =  %f \n", thr_cw1_tot);
         printf("Throughput cw1 round 0 =  %f \n", thr_cw1[0]);
         printf("Throughput cw1 round 1 =  %f \n", thr_cw1[1]);
@@ -4288,6 +4332,7 @@ n(tikz_fname,"w");
         printf("round_trials[1][0] =  %d, errs[1][0] = %d, round_trials[1][1] = %d, errs[1][1] = %d, round_trials[1][2] = %d, errs[1][2] = %d, \
           round_trials[1][3] = %d, errs[1][3] = %d \n", round_trials[1][0], errs[1][0], round_trials[1][1], errs[1][1], round_trials[1][2], \
           errs[1][2], round_trials[1][3], errs[1][3]);
+#endif
       }
 
 #if 0
@@ -4494,27 +4539,39 @@ n(tikz_fname,"w");
                 SNR,
                 mcs1,
                 mcs2,
-                PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->TBS,
-                PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->TBS,
-                rate[0],
-                rate[1],
+                tbs0_init,
+                tbs1_init,
+                rate0_init,
+                rate1_init,
                 errs[0][0],
                 errs[1][0],
                 round_trials[0][0],
+                round_trials[1][0],
                 errs[0][1],
                 errs[1][1],
                 round_trials[0][1],
+                round_trials[1][1],
                 errs[0][2],
                 errs[1][2],
                 round_trials[0][2],
+                round_trials[1][2],
                 errs[0][3],
                 errs[1][3],
                 round_trials[0][3],
-                rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)*(1-((double)errs[0][0]/(double)round_trials[0][0])),
-                rate[1]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)*(1-((double)errs[1][0]/(double)round_trials[1][0])),
-                rate[0]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs)*(1-((double)errs[0][0]/(double)round_trials[0][0]))+
-                rate[1]*get_Qm(PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->mcs)*(1-((double)errs[1][0]/(double)round_trials[1][0])),
-                dci_errors);
+                round_trials[1][3],
+                thr_cw0[0],
+                thr_cw1[0],
+                thr_cw0[0]+thr_cw1[0],
+                thr_cw0[1],
+                thr_cw1[1],
+                thr_cw0[1]+thr_cw1[1],
+                thr_cw0[2],
+                thr_cw1[2],
+                thr_cw0[2]+thr_cw1[2],
+                thr_cw0[3],
+                thr_cw1[3],
+                thr_cw0[3]+thr_cw1[3],
+                thr_cw0[0]+thr_cw0[1]+thr_cw0[2]+thr_cw0[4]+thr_cw1[0]+thr_cw1[1]+thr_cw1[2]+ thr_cw1[3]);
             }
 
 
@@ -4742,7 +4799,7 @@ n(tikz_fname,"w");
   }
 
 
-      if (n_frames==1)
+      if (n_frames==2)
   break;
 
       }// SNR
diff --git a/openair1/SIMULATION/TOOLS/random_channel.c b/openair1/SIMULATION/TOOLS/random_channel.c
index 05995bf1f43058f84e761f1362b579d794562743..8f3cc7c8bd697b53cd7274035ddff65e41709089 100644
--- a/openair1/SIMULATION/TOOLS/random_channel.c
+++ b/openair1/SIMULATION/TOOLS/random_channel.c
@@ -1,5 +1,5 @@
 /*******************************************************************************
-    OpenAirInterface 
+    OpenAirInterface
     Copyright(c) 1999 - 2014 Eurecom
 
     OpenAirInterface is free software: you can redistribute it and/or modify
@@ -14,15 +14,15 @@
     GNU General Public License for more details.
 
     You should have received a copy of the GNU General Public License
-    along with OpenAirInterface.The full GNU General Public License is 
-   included in this distribution in the file called "COPYING". If not, 
+    along with OpenAirInterface.The full GNU General Public License is
+   included in this distribution in the file called "COPYING". If not,
    see <http://www.gnu.org/licenses/>.
 
   Contact Information
   OpenAirInterface Admin: openair_admin@eurecom.fr
   OpenAirInterface Tech : openair_tech@eurecom.fr
   OpenAirInterface Dev  : openair4g-devel@eurecom.fr
-  
+
   Address      : Eurecom, Campus SophiaTech, 450 Route des Chappes, CS 50193 - 06904 Biot Sophia Antipolis cedex, FRANCE
 
  *******************************************************************************/
@@ -82,28 +82,28 @@ void fill_channel_desc(channel_desc_t *chan_desc,
   }
   else
   chan_desc->delays              = delays;
-  chan_desc->Td               	        = Td;
+  chan_desc->Td                         = Td;
   chan_desc->sampling_rate              = sampling_rate;
   chan_desc->channel_bandwidth          = channel_bandwidth;
-  chan_desc->ricean_factor 		= ricean_factor;
-  chan_desc->aoa            		= aoa;
-  chan_desc->random_aoa  		= random_aoa;
-  chan_desc->forgetting_factor 		= forgetting_factor;
-  chan_desc->channel_offset 		= channel_offset;
-  chan_desc->path_loss_dB   		= path_loss_dB;
-  chan_desc->first_run      		= 1;
-  chan_desc->ip             		= 0.0;
-  chan_desc->max_Doppler    		= max_Doppler;
-  chan_desc->ch             		= (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*));
-  chan_desc->chF            		= (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*));
-  chan_desc->a              		= (struct complex**) malloc(nb_taps*sizeof(struct complex*));
+  chan_desc->ricean_factor              = ricean_factor;
+  chan_desc->aoa                        = aoa;
+  chan_desc->random_aoa                 = random_aoa;
+  chan_desc->forgetting_factor          = forgetting_factor;
+  chan_desc->channel_offset             = channel_offset;
+  chan_desc->path_loss_dB               = path_loss_dB;
+  chan_desc->first_run                  = 1;
+  chan_desc->ip                         = 0.0;
+  chan_desc->max_Doppler                = max_Doppler;
+  chan_desc->ch                         = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*));
+  chan_desc->chF                        = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*));
+  chan_desc->a                          = (struct complex**) malloc(nb_taps*sizeof(struct complex*));
 
   LOG_D(OCM,"[CHANNEL] Filling ch \n");
 
-  for (i = 0; i<nb_tx*nb_rx; i++) 
-    chan_desc->ch[i] = (struct complex*) malloc(channel_length * sizeof(struct complex)); 
+  for (i = 0; i<nb_tx*nb_rx; i++)
+    chan_desc->ch[i] = (struct complex*) malloc(channel_length * sizeof(struct complex));
 
-  for (i = 0; i<nb_tx*nb_rx; i++) 
+  for (i = 0; i<nb_tx*nb_rx; i++)
     chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex));  // allocate for up to 100 RBs, 12 samples per RB
 
   LOG_D(OCM,"[CHANNEL] Filling a (nb_taps %d)\n",nb_taps);
@@ -118,8 +118,8 @@ void fill_channel_desc(channel_desc_t *chan_desc,
     for (i = 0; i<nb_taps; i++) {
         chan_desc->R_sqrt[i]    = (struct complex*) calloc(nb_tx*nb_rx*nb_tx*nb_rx,sizeof(struct complex));
       for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) {
-	chan_desc->R_sqrt[i][j].x = 1.0;
-	chan_desc->R_sqrt[i][j].y = 0.0;
+        chan_desc->R_sqrt[i][j].x = 1.0;
+        chan_desc->R_sqrt[i][j].y = 0.0;
       }
     }
   }
@@ -127,9 +127,9 @@ void fill_channel_desc(channel_desc_t *chan_desc,
     chan_desc->R_sqrt = (struct complex**) calloc(nb_taps,sizeof(struct complex*));
     for (i = 0; i<nb_taps; i++) {
         chan_desc->R_sqrt[i]    = (struct complex*) calloc(nb_tx*nb_rx*nb_tx*nb_rx,sizeof(struct complex));
-	//chan_desc->R_sqrt = (struct complex*)&R_sqrt[i][0];
-	chan_desc->R_sqrt[i] = R_sqrt[0];
-	}	
+        //chan_desc->R_sqrt = (struct complex*)&R_sqrt[i][0];
+        chan_desc->R_sqrt[i] = R_sqrt[0];
+        }
   }
 
   for (i = 0; i<nb_taps; i++) {
@@ -172,36 +172,36 @@ double default_amp_lin[] = {1};
 double ts_shift_delays[] = {0, 1/7.68};
 double ts_shift_amps[] = {0, 1};
 
-//correlation matrix for a 2x2 channel with full Tx correlation 
-struct complex R_sqrt_22_corr_tap[16] = {{0.70711,0}, {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, 
-					{0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, {0.70711,0},
-					{0.70711,0}, {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, 
-					{0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, {0.70711,0}};
+//correlation matrix for a 2x2 channel with full Tx correlation
+struct complex R_sqrt_22_corr_tap[16] = {{0.70711,0}, {0.0, 0.0}, {0.70711,0}, {0.0, 0.0},
+                                        {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, {0.70711,0},
+                                        {0.70711,0}, {0.0, 0.0}, {0.70711,0}, {0.0, 0.0},
+                                        {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, {0.70711,0}};
 struct complex *R_sqrt_22_corr[1]     = {R_sqrt_22_corr_tap};
 
 //correlation matrix for a fully correlated 2x1 channel (h1==h2)
-struct complex R_sqrt_21_corr_tap[4]  = {{0.70711,0}, {0.70711,0}, {0.70711,0}, {0.70711,0}}; 
+struct complex R_sqrt_21_corr_tap[4]  = {{0.70711,0}, {0.70711,0}, {0.70711,0}, {0.70711,0}};
 struct complex *R_sqrt_21_corr[1]      = {R_sqrt_21_corr_tap};
 
-//correlation matrix for a 2x2 channel with full Tx anti-correlation 
-struct complex R_sqrt_22_anticorr_tap[16] = {{0.70711,0}, {0.0, 0.0}, {-0.70711,0}, {0.0, 0.0}, 
-					     {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, {-0.70711,0},
-					     {-0.70711,0}, {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, 
-					     {0.0, 0.0}, {-0.70711,0}, {0.0, 0.0}, {0.70711,0}};
+//correlation matrix for a 2x2 channel with full Tx anti-correlation
+struct complex R_sqrt_22_anticorr_tap[16] = {{0.70711,0}, {0.0, 0.0}, {-0.70711,0}, {0.0, 0.0},
+                                             {0.0, 0.0}, {0.70711,0}, {0.0, 0.0}, {-0.70711,0},
+                                             {-0.70711,0}, {0.0, 0.0}, {0.70711,0}, {0.0, 0.0},
+                                             {0.0, 0.0}, {-0.70711,0}, {0.0, 0.0}, {0.70711,0}};
 struct complex *R_sqrt_22_anticorr[1]     = {R_sqrt_22_anticorr_tap};
 
 //correlation matrix for a fully anti-correlated 2x1 channel (h1==-h2)
-struct complex R_sqrt_21_anticorr_tap[4]  = {{0.70711,0}, {-0.70711,0}, {-0.70711,0}, {0.70711,0}}; 
+struct complex R_sqrt_21_anticorr_tap[4]  = {{0.70711,0}, {-0.70711,0}, {-0.70711,0}, {0.70711,0}};
 struct complex *R_sqrt_21_anticorr[1]     = {R_sqrt_21_anticorr_tap};
 
 struct complex **R_sqrt_ptr2;
 
 // full correlation matrix in vectorized form for 2x2 channel, where h1 is  perfectly orthogonal to h2
 
-struct complex R_sqrt_22_orthogonal_tap[16] = {{0.70711,0.0}, {0.0, 0.0}, {0.0,0.0}, {0.0, 0.0}, 
-							{0.0, 0.0}, {0.0,0.0}, {0.0, 0.0}, {0.0,0.0},
-							{0.0,0.0}, {0.0, 0.0}, {0.0,0.0}, {0.0, 0.0}, 
-							{0.0, 0.0}, {0.0,0.0}, {0.0, 0.0}, {0.70711,0.0}};
+struct complex R_sqrt_22_orthogonal_tap[16] = {{0.70711,0.0}, {0.0, 0.0}, {0.0,0.0}, {0.0, 0.0},
+                                                        {0.0, 0.0}, {0.0,0.0}, {0.0, 0.0}, {0.0,0.0},
+                                                        {0.0,0.0}, {0.0, 0.0}, {0.0,0.0}, {0.0, 0.0},
+                                                        {0.0, 0.0}, {0.0,0.0}, {0.0, 0.0}, {0.70711,0.0}};
 struct complex *R_sqrt_22_orthogonal[1]     = {R_sqrt_22_orthogonal_tap};
 
 // full correlation matrix for TM4 to make orthogonal effective channel
@@ -209,19 +209,19 @@ struct complex *R_sqrt_22_orthogonal[1]     = {R_sqrt_22_orthogonal_tap};
 
 
 
-struct complex R_sqrt_22_orth_eff_ch_TM4_prec_real_tap[16] = {{0.70711,0.0}, {0.0, 0.0}, {0.70711,0.0}, {0.0, 0.0}, 
-							{0.0, 0.0}, {0.70711,0.0}, {0.0, 0.0}, {-0.70711,0.0},
-							{0.70711,0.0}, {0.0, 0.0}, {0.70711,0.0}, {0.0, 0.0}, 
-							{0.0, 0.0}, {-0.70711,0.0}, {0.0, 0.0}, {0.70711,0.0}};				
+struct complex R_sqrt_22_orth_eff_ch_TM4_prec_real_tap[16] = {{0.70711,0.0}, {0.0, 0.0}, {0.70711,0.0}, {0.0, 0.0},
+                                                        {0.0, 0.0}, {0.70711,0.0}, {0.0, 0.0}, {-0.70711,0.0},
+                                                        {0.70711,0.0}, {0.0, 0.0}, {0.70711,0.0}, {0.0, 0.0},
+                                                        {0.0, 0.0}, {-0.70711,0.0}, {0.0, 0.0}, {0.70711,0.0}};
 struct complex *R_sqrt_22_orth_eff_ch_TM4_prec_real[1]     = {R_sqrt_22_orth_eff_ch_TM4_prec_real_tap};
 
 
 
 
-struct complex R_sqrt_22_orth_eff_ch_TM4_prec_imag_tap[16] = {{0.70711,0.0}, {0.0,0.0}, {0.0, -0.70711}, {0.0,0.0}, 
-							{0.0, 0.0}, {0.70711,0.0}, {0.0, 0.0}, {0.0,0.70711},
-							{0.0,-0.70711}, {0.0, 0.0}, {-0.70711,0.0}, {0.0, 0.0}, 
-							{0.0, 0.0}, {0.0,0.70711}, {0.0, 0.0}, {-0.70711,0.0}};
+struct complex R_sqrt_22_orth_eff_ch_TM4_prec_imag_tap[16] = {{0.70711,0.0}, {0.0,0.0}, {0.0, -0.70711}, {0.0,0.0},
+                                                        {0.0, 0.0}, {0.70711,0.0}, {0.0, 0.0}, {0.0,0.70711},
+                                                        {0.0,-0.70711}, {0.0, 0.0}, {-0.70711,0.0}, {0.0, 0.0},
+                                                        {0.0, 0.0}, {0.0,0.70711}, {0.0, 0.0}, {-0.70711,0.0}};
 struct complex *R_sqrt_22_orth_eff_ch_TM4_prec_imag[1]     = {R_sqrt_22_orth_eff_ch_TM4_prec_imag_tap};
 
 
@@ -232,7 +232,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
                                      uint8_t nb_rx,
                                      SCM_t channel_model,
                                      double sampling_rate,
-				     double channel_bandwidth,
+                                     double channel_bandwidth,
                                      double forgetting_factor,
                                      int32_t channel_offset,
                                      double path_loss_dB)
@@ -244,15 +244,15 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
   double aoa,ricean_factor,Td,maxDoppler;
   int channel_length,nb_taps;
 
-  chan_desc->nb_tx          		= nb_tx;
-  chan_desc->nb_rx          		= nb_rx;
+  chan_desc->nb_tx                      = nb_tx;
+  chan_desc->nb_rx                      = nb_rx;
   chan_desc->sampling_rate              = sampling_rate;
   chan_desc->channel_bandwidth          = channel_bandwidth;
-  chan_desc->forgetting_factor 		= forgetting_factor;
-  chan_desc->channel_offset 		= channel_offset;
-  chan_desc->path_loss_dB   		= path_loss_dB;
-  chan_desc->first_run      		= 1;
-  chan_desc->ip             			= 0.0;
+  chan_desc->forgetting_factor          = forgetting_factor;
+  chan_desc->channel_offset             = channel_offset;
+  chan_desc->path_loss_dB               = path_loss_dB;
+  chan_desc->first_run                  = 1;
+  chan_desc->ip                                 = 0.0;
 
   LOG_I(OCM,"Channel Model (inside of new_channel_desc_scm)=%d\n\n", channel_model);
 
@@ -272,7 +272,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
     sum_amps = 0;
     chan_desc->amps           = (double*) malloc(chan_desc->nb_taps*sizeof(double));
     for (i = 0; i<chan_desc->nb_taps; i++) {
-      chan_desc->amps[i]      = pow(10,.1*scm_c_amps_dB[i]); 
+      chan_desc->amps[i]      = pow(10,.1*scm_c_amps_dB[i]);
       sum_amps += chan_desc->amps[i];
     }
     for (i = 0; i<chan_desc->nb_taps; i++)
@@ -284,34 +284,34 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
     chan_desc->ch             = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*));
     chan_desc->chF            = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*));
     chan_desc->a              = (struct complex**) malloc(chan_desc->nb_taps*sizeof(struct complex*));
-    for (i = 0; i<nb_tx*nb_rx; i++) 
-      chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); 
-    for (i = 0; i<nb_tx*nb_rx; i++) 
-      chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); 
-    for (i = 0; i<chan_desc->nb_taps; i++) 
+    for (i = 0; i<nb_tx*nb_rx; i++)
+      chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex));
+    for (i = 0; i<nb_tx*nb_rx; i++)
+      chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex));
+    for (i = 0; i<chan_desc->nb_taps; i++)
       chan_desc->a[i]         = (struct complex*) malloc(nb_tx*nb_rx * sizeof(struct complex));
 
     chan_desc->R_sqrt  = (struct complex**) malloc(6*sizeof(struct complex**));
     if (nb_tx==2 && nb_rx==2) {
-      for (i = 0; i<6; i++) 
-	chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0];
+      for (i = 0; i<6; i++)
+        chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0];
     }
     else if (nb_tx==2 && nb_rx==1) {
-      for (i = 0; i<6; i++) 
-	chan_desc->R_sqrt[i] = (struct complex*) &R21_sqrt[i][0];
+      for (i = 0; i<6; i++)
+        chan_desc->R_sqrt[i] = (struct complex*) &R21_sqrt[i][0];
     }
     else if (nb_tx==1 && nb_rx==2) {
-      for (i = 0; i<6; i++) 
-	chan_desc->R_sqrt[i] = (struct complex*) &R12_sqrt[i][0];
+      for (i = 0; i<6; i++)
+        chan_desc->R_sqrt[i] = (struct complex*) &R12_sqrt[i][0];
     }
     else {
       for (i = 0; i<6; i++) {
-	chan_desc->R_sqrt[i]    = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
-	for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) {
-	  chan_desc->R_sqrt[i][j].x = 1.0;
-	  chan_desc->R_sqrt[i][j].y = 0.0;
-	}
-	LOG_W(OCM,"correlation matrix not implemented for nb_tx==%d and nb_rx==%d, using identity\n", nb_tx, nb_rx);
+        chan_desc->R_sqrt[i]    = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
+        for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) {
+          chan_desc->R_sqrt[i][j].x = 1.0;
+          chan_desc->R_sqrt[i][j].y = 0.0;
+        }
+        LOG_W(OCM,"correlation matrix not implemented for nb_tx==%d and nb_rx==%d, using identity\n", nb_tx, nb_rx);
       }
     }
     break;
@@ -323,7 +323,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
     sum_amps = 0;
     chan_desc->amps           = (double*) malloc(chan_desc->nb_taps*sizeof(double));
     for (i = 0; i<chan_desc->nb_taps; i++) {
-      chan_desc->amps[i]      = pow(10,.1*scm_c_amps_dB[i]); 
+      chan_desc->amps[i]      = pow(10,.1*scm_c_amps_dB[i]);
       sum_amps += chan_desc->amps[i];
     }
     for (i = 0; i<chan_desc->nb_taps; i++)
@@ -335,34 +335,34 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
     chan_desc->ch             = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*));
     chan_desc->chF            = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*));
     chan_desc->a              = (struct complex**) malloc(chan_desc->nb_taps*sizeof(struct complex*));
-    for (i = 0; i<nb_tx*nb_rx; i++) 
-      chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); 
-    for (i = 0; i<nb_tx*nb_rx; i++) 
-      chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); 
-    for (i = 0; i<chan_desc->nb_taps; i++) 
+    for (i = 0; i<nb_tx*nb_rx; i++)
+      chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex));
+    for (i = 0; i<nb_tx*nb_rx; i++)
+      chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex));
+    for (i = 0; i<chan_desc->nb_taps; i++)
       chan_desc->a[i]         = (struct complex*) malloc(nb_tx*nb_rx * sizeof(struct complex));
 
     chan_desc->R_sqrt  = (struct complex**) malloc(6*sizeof(struct complex**));
     if (nb_tx==2 && nb_rx==2) {
-      for (i = 0; i<6; i++) 
-	chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0];
+      for (i = 0; i<6; i++)
+        chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0];
     }
     else if (nb_tx==2 && nb_rx==1) {
-      for (i = 0; i<6; i++) 
-	chan_desc->R_sqrt[i] = (struct complex*) &R21_sqrt[i][0];
+      for (i = 0; i<6; i++)
+        chan_desc->R_sqrt[i] = (struct complex*) &R21_sqrt[i][0];
     }
     else if (nb_tx==1 && nb_rx==2) {
-      for (i = 0; i<6; i++) 
-	chan_desc->R_sqrt[i] = (struct complex*) &R12_sqrt[i][0];
+      for (i = 0; i<6; i++)
+        chan_desc->R_sqrt[i] = (struct complex*) &R12_sqrt[i][0];
     }
     else {
       for (i = 0; i<6; i++) {
-	chan_desc->R_sqrt[i]    = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
-	for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) {
-	  chan_desc->R_sqrt[i][j].x = 1.0;
-	  chan_desc->R_sqrt[i][j].y = 0.0;
-	}
-	LOG_W(OCM,"correlation matrix not implemented for nb_tx==%d and nb_rx==%d, using identity\n", nb_tx, nb_rx);
+        chan_desc->R_sqrt[i]    = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
+        for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) {
+          chan_desc->R_sqrt[i][j].x = 1.0;
+          chan_desc->R_sqrt[i][j].y = 0.0;
+        }
+        LOG_W(OCM,"correlation matrix not implemented for nb_tx==%d and nb_rx==%d, using identity\n", nb_tx, nb_rx);
       }
     }
     break;
@@ -373,7 +373,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
     sum_amps = 0;
     chan_desc->amps           = (double*) malloc(chan_desc->nb_taps*sizeof(double));
     for (i = 0; i<chan_desc->nb_taps; i++) {
-      chan_desc->amps[i]      = pow(10,.1*epa_amps_dB[i]); 
+      chan_desc->amps[i]      = pow(10,.1*epa_amps_dB[i]);
       sum_amps += chan_desc->amps[i];
     }
     for (i = 0; i<chan_desc->nb_taps; i++)
@@ -385,26 +385,26 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
     chan_desc->ch             = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*));
     chan_desc->chF            = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*));
     chan_desc->a              = (struct complex**) malloc(chan_desc->nb_taps*sizeof(struct complex*));
-    for (i = 0; i<nb_tx*nb_rx; i++) 
-      chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); 
-    for (i = 0; i<nb_tx*nb_rx; i++) 
-      chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); 
-    for (i = 0; i<chan_desc->nb_taps; i++) 
+    for (i = 0; i<nb_tx*nb_rx; i++)
+      chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex));
+    for (i = 0; i<nb_tx*nb_rx; i++)
+      chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex));
+    for (i = 0; i<chan_desc->nb_taps; i++)
       chan_desc->a[i]         = (struct complex*) malloc(nb_tx*nb_rx * sizeof(struct complex));
     if (nb_tx==2 && nb_rx==2) {
       chan_desc->R_sqrt  = (struct complex**) malloc(6*sizeof(struct complex**));
-      for (i = 0; i<6; i++) 
-	chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0];
+      for (i = 0; i<6; i++)
+        chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0];
     }
     else {
       chan_desc->R_sqrt         = (struct complex**) malloc(6*sizeof(struct complex**));
       for (i = 0; i<6; i++) {
-	chan_desc->R_sqrt[i]    = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
-	for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) {
-	  chan_desc->R_sqrt[i][j].x = 1.0;
-	  chan_desc->R_sqrt[i][j].y = 0.0;
-	}
-	LOG_W(OCM,"correlation matrix only implemented for nb_tx==2 and nb_rx==2, using identity\n");
+        chan_desc->R_sqrt[i]    = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
+        for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) {
+          chan_desc->R_sqrt[i][j].x = 1.0;
+          chan_desc->R_sqrt[i][j].y = 0.0;
+        }
+        LOG_W(OCM,"correlation matrix only implemented for nb_tx==2 and nb_rx==2, using identity\n");
       }
     }
     break;
@@ -415,7 +415,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
     sum_amps = 0;
     chan_desc->amps           = (double*) malloc(chan_desc->nb_taps*sizeof(double));
     for (i = 0; i<chan_desc->nb_taps; i++) {
-      chan_desc->amps[i]      = pow(10,.1*eva_amps_dB[i]); 
+      chan_desc->amps[i]      = pow(10,.1*eva_amps_dB[i]);
       sum_amps += chan_desc->amps[i];
     }
     for (i = 0; i<chan_desc->nb_taps; i++)
@@ -427,26 +427,26 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
     chan_desc->ch             = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*));
     chan_desc->chF            = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*));
     chan_desc->a              = (struct complex**) malloc(chan_desc->nb_taps*sizeof(struct complex*));
-    for (i = 0; i<nb_tx*nb_rx; i++) 
-      chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); 
-    for (i = 0; i<nb_tx*nb_rx; i++) 
-      chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); 
-    for (i = 0; i<chan_desc->nb_taps; i++) 
+    for (i = 0; i<nb_tx*nb_rx; i++)
+      chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex));
+    for (i = 0; i<nb_tx*nb_rx; i++)
+      chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex));
+    for (i = 0; i<chan_desc->nb_taps; i++)
       chan_desc->a[i]         = (struct complex*) malloc(nb_tx*nb_rx * sizeof(struct complex));
     if (nb_tx==2 && nb_rx==2) {
       chan_desc->R_sqrt  = (struct complex**) malloc(6*sizeof(struct complex**));
-      for (i = 0; i<6; i++) 
-	chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0];
+      for (i = 0; i<6; i++)
+        chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0];
     }
     else {
       chan_desc->R_sqrt         = (struct complex**) malloc(6*sizeof(struct complex**));
       for (i = 0; i<6; i++) {
-	chan_desc->R_sqrt[i]    = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
-	for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) {
-	  chan_desc->R_sqrt[i][j].x = 1.0;
-	  chan_desc->R_sqrt[i][j].y = 0.0;
-	}
-	LOG_W(OCM,"correlation matrix only implemented for nb_tx==2 and nb_rx==2, using identity\n");
+        chan_desc->R_sqrt[i]    = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
+        for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) {
+          chan_desc->R_sqrt[i][j].x = 1.0;
+          chan_desc->R_sqrt[i][j].y = 0.0;
+        }
+        LOG_W(OCM,"correlation matrix only implemented for nb_tx==2 and nb_rx==2, using identity\n");
       }
     }
     break;
@@ -457,7 +457,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
     sum_amps = 0;
     chan_desc->amps           = (double*) malloc(chan_desc->nb_taps*sizeof(double));
     for (i = 0; i<chan_desc->nb_taps; i++) {
-      chan_desc->amps[i]      = pow(10,.1*etu_amps_dB[i]); 
+      chan_desc->amps[i]      = pow(10,.1*etu_amps_dB[i]);
       sum_amps += chan_desc->amps[i];
     }
     for (i = 0; i<chan_desc->nb_taps; i++)
@@ -469,26 +469,26 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
     chan_desc->ch             = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*));
     chan_desc->chF            = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*));
     chan_desc->a              = (struct complex**) malloc(chan_desc->nb_taps*sizeof(struct complex*));
-    for (i = 0; i<nb_tx*nb_rx; i++) 
-      chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); 
-    for (i = 0; i<nb_tx*nb_rx; i++) 
-      chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); 
-    for (i = 0; i<chan_desc->nb_taps; i++) 
+    for (i = 0; i<nb_tx*nb_rx; i++)
+      chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex));
+    for (i = 0; i<nb_tx*nb_rx; i++)
+      chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex));
+    for (i = 0; i<chan_desc->nb_taps; i++)
       chan_desc->a[i]         = (struct complex*) malloc(nb_tx*nb_rx * sizeof(struct complex));
     if (nb_tx==2 && nb_rx==2) {
       chan_desc->R_sqrt  = (struct complex**) malloc(6*sizeof(struct complex**));
-      for (i = 0; i<6; i++) 
-	chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0];
+      for (i = 0; i<6; i++)
+        chan_desc->R_sqrt[i] = (struct complex*) &R22_sqrt[i][0];
     }
     else {
       chan_desc->R_sqrt         = (struct complex**) malloc(6*sizeof(struct complex**));
       for (i = 0; i<6; i++) {
-	chan_desc->R_sqrt[i]    = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
-	for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) {
-	  chan_desc->R_sqrt[i][j].x = 1.0;
-	  chan_desc->R_sqrt[i][j].y = 0.0;
-	}
-	LOG_W(OCM,"correlation matrix only implemented for nb_tx==2 and nb_rx==2, using identity\n");
+        chan_desc->R_sqrt[i]    = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
+        for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) {
+          chan_desc->R_sqrt[i][j].x = 1.0;
+          chan_desc->R_sqrt[i][j].y = 0.0;
+        }
+        LOG_W(OCM,"correlation matrix only implemented for nb_tx==2 and nb_rx==2, using identity\n");
       }
     }
     break;
@@ -499,7 +499,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
     sum_amps = 0;
     chan_desc->amps           = (double*) malloc(chan_desc->nb_taps*sizeof(double));
     for (i = 0; i<chan_desc->nb_taps; i++) {
-      chan_desc->amps[i]      = pow(10,.1*mbsfn_amps_dB[i]); 
+      chan_desc->amps[i]      = pow(10,.1*mbsfn_amps_dB[i]);
       sum_amps += chan_desc->amps[i];
     }
     for (i = 0; i<chan_desc->nb_taps; i++)
@@ -511,19 +511,19 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
     chan_desc->ch             = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*));
     chan_desc->chF            = (struct complex**) malloc(nb_tx*nb_rx*sizeof(struct complex*));
     chan_desc->a              = (struct complex**) malloc(chan_desc->nb_taps*sizeof(struct complex*));
-    for (i = 0; i<nb_tx*nb_rx; i++) 
-      chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex)); 
-    for (i = 0; i<nb_tx*nb_rx; i++) 
-      chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex)); 
-    for (i = 0; i<chan_desc->nb_taps; i++) 
+    for (i = 0; i<nb_tx*nb_rx; i++)
+      chan_desc->ch[i] = (struct complex*) malloc(chan_desc->channel_length * sizeof(struct complex));
+    for (i = 0; i<nb_tx*nb_rx; i++)
+      chan_desc->chF[i] = (struct complex*) malloc(1200 * sizeof(struct complex));
+    for (i = 0; i<chan_desc->nb_taps; i++)
       chan_desc->a[i]         = (struct complex*) malloc(nb_tx*nb_rx * sizeof(struct complex));
 
     chan_desc->R_sqrt  = (struct complex**) malloc(6*sizeof(struct complex*));
     for (i = 0; i<6; i++) {
       chan_desc->R_sqrt[i]    = (struct complex*) malloc(nb_tx*nb_rx*nb_tx*nb_rx * sizeof(struct complex));
       for (j = 0; j<nb_tx*nb_rx*nb_tx*nb_rx; j+=(nb_tx*nb_rx+1)) {
-	chan_desc->R_sqrt[i][j].x = 1.0;
-	chan_desc->R_sqrt[i][j].y = 0.0;
+        chan_desc->R_sqrt[i][j].x = 1.0;
+        chan_desc->R_sqrt[i][j].y = 0.0;
       }
       LOG_W(OCM,"correlation matrix only implemented for nb_tx==2 and nb_rx==2, using identity\n");
     }
@@ -538,23 +538,23 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       maxDoppler = 0;
 
       fill_channel_desc(chan_desc,
-			nb_tx,
-			nb_rx,
-			nb_taps,
-			channel_length,
-			default_amps_lin,
-			NULL,
-			NULL,
-			Td,
-			sampling_rate,
-			channel_bandwidth,
-			ricean_factor,
-			aoa,
-			forgetting_factor,
-			maxDoppler,
-			channel_offset, 
-			path_loss_dB,
-			0);
+                        nb_tx,
+                        nb_rx,
+                        nb_taps,
+                        channel_length,
+                        default_amps_lin,
+                        NULL,
+                        NULL,
+                        Td,
+                        sampling_rate,
+                        channel_bandwidth,
+                        ricean_factor,
+                        aoa,
+                        forgetting_factor,
+                        maxDoppler,
+                        channel_offset,
+                        path_loss_dB,
+                        0);
       break;
 
   case Rice8:
@@ -566,22 +566,22 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       maxDoppler = 0;
 
       fill_channel_desc(chan_desc,nb_tx,
-				   nb_rx,
-				   nb_taps,
-				   channel_length,
-				   default_amps_lin,
-				   NULL,
-				   NULL,
-				   Td,
-				   sampling_rate,
-				   channel_bandwidth,
-				   ricean_factor,
-				   aoa,
-				   forgetting_factor,
-				   maxDoppler,
-				   channel_offset, 
-				   path_loss_dB,
-				   1);
+                                   nb_rx,
+                                   nb_taps,
+                                   channel_length,
+                                   default_amps_lin,
+                                   NULL,
+                                   NULL,
+                                   Td,
+                                   sampling_rate,
+                                   channel_bandwidth,
+                                   ricean_factor,
+                                   aoa,
+                                   forgetting_factor,
+                                   maxDoppler,
+                                   channel_offset,
+                                   path_loss_dB,
+                                   1);
       break;
 
   case Rayleigh1:
@@ -593,22 +593,22 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       maxDoppler = 0;
 
       fill_channel_desc(chan_desc,nb_tx,
-				   nb_rx,
-				   nb_taps,
-				   channel_length,
-				   default_amp_lin,
-				   NULL,
-				   NULL,
-				   Td,
-				   sampling_rate,
-				   channel_bandwidth,
-				   ricean_factor,
-				   aoa,
-				   forgetting_factor,
-				   maxDoppler,
-				   channel_offset, 
-				   path_loss_dB,
-				   0);
+                                   nb_rx,
+                                   nb_taps,
+                                   channel_length,
+                                   default_amp_lin,
+                                   NULL,
+                                   NULL,
+                                   Td,
+                                   sampling_rate,
+                                   channel_bandwidth,
+                                   ricean_factor,
+                                   aoa,
+                                   forgetting_factor,
+                                   maxDoppler,
+                                   channel_offset,
+                                   path_loss_dB,
+                                   0);
       break;
 
   case Rayleigh1_800:
@@ -620,22 +620,22 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       maxDoppler = 800;
 
       fill_channel_desc(chan_desc,nb_tx,
-				   nb_rx,
-				   nb_taps,
-				   channel_length,
-				   default_amp_lin,
-				   NULL,
-				   NULL,
-				   Td,
-				   sampling_rate,
-				   channel_bandwidth,
-				   ricean_factor,
-				   aoa,
-				   forgetting_factor,
-				   maxDoppler,
-				   channel_offset, 
-				   path_loss_dB,
-				   0);
+                                   nb_rx,
+                                   nb_taps,
+                                   channel_length,
+                                   default_amp_lin,
+                                   NULL,
+                                   NULL,
+                                   Td,
+                                   sampling_rate,
+                                   channel_bandwidth,
+                                   ricean_factor,
+                                   aoa,
+                                   forgetting_factor,
+                                   maxDoppler,
+                                   channel_offset,
+                                   path_loss_dB,
+                                   0);
       break;
 
   case Rayleigh1_corr:
@@ -647,31 +647,31 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       maxDoppler = 0;
 
       if ((nb_tx==2) && (nb_rx==1)) {
-	R_sqrt_ptr2 = R_sqrt_21_corr;
+        R_sqrt_ptr2 = R_sqrt_21_corr;
       }
       else if ((nb_tx==2) && (nb_rx==2)) {
-	R_sqrt_ptr2 = R_sqrt_22_corr;
+        R_sqrt_ptr2 = R_sqrt_22_corr;
       }
       else
-	R_sqrt_ptr2 = NULL;
+        R_sqrt_ptr2 = NULL;
 
       fill_channel_desc(chan_desc,nb_tx,
-				   nb_rx,
-				   nb_taps,
-				   channel_length,
-				   default_amp_lin,
-				   NULL,
-				   R_sqrt_ptr2,
-				   Td,
-				   sampling_rate,
-				   channel_bandwidth,
-				   ricean_factor,
-				   aoa,
-				   forgetting_factor,
-				   maxDoppler,
-				   channel_offset, 
-				   path_loss_dB,
-				   0);
+                                   nb_rx,
+                                   nb_taps,
+                                   channel_length,
+                                   default_amp_lin,
+                                   NULL,
+                                   R_sqrt_ptr2,
+                                   Td,
+                                   sampling_rate,
+                                   channel_bandwidth,
+                                   ricean_factor,
+                                   aoa,
+                                   forgetting_factor,
+                                   maxDoppler,
+                                   channel_offset,
+                                   path_loss_dB,
+                                   0);
       break;
 
   case Rayleigh1_anticorr:
@@ -683,31 +683,31 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       maxDoppler = 0;
 
       if ((nb_tx==2) && (nb_rx==1)) { //check this
-	R_sqrt_ptr2 = R_sqrt_21_anticorr;
+        R_sqrt_ptr2 = R_sqrt_21_anticorr;
       }
       else if ((nb_tx==2) && (nb_rx==2)) {
-	R_sqrt_ptr2 = R_sqrt_22_anticorr;
+        R_sqrt_ptr2 = R_sqrt_22_anticorr;
       }
-      else 
-	R_sqrt_ptr2 = NULL;
+      else
+        R_sqrt_ptr2 = NULL;
 
       fill_channel_desc(chan_desc,nb_tx,
-				   nb_rx,
-				   nb_taps,
-				   channel_length,
-				   default_amp_lin,
-				   NULL,
-				   R_sqrt_ptr2,
-				   Td,
-				   sampling_rate,
-				   channel_bandwidth,
-				   ricean_factor,
-				   aoa,
-				   forgetting_factor,
-				   maxDoppler,
-				   channel_offset, 
-				   path_loss_dB,
-				   0);
+                                   nb_rx,
+                                   nb_taps,
+                                   channel_length,
+                                   default_amp_lin,
+                                   NULL,
+                                   R_sqrt_ptr2,
+                                   Td,
+                                   sampling_rate,
+                                   channel_bandwidth,
+                                   ricean_factor,
+                                   aoa,
+                                   forgetting_factor,
+                                   maxDoppler,
+                                   channel_offset,
+                                   path_loss_dB,
+                                   0);
       break;
 
   case Rice1:
@@ -719,22 +719,22 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       maxDoppler = 0;
 
       fill_channel_desc(chan_desc,nb_tx,
-				   nb_rx,
-				   nb_taps,
-				   channel_length,
-				   default_amp_lin,
-				   NULL,
-				   NULL,
-				   Td,
-				   sampling_rate,
-				   channel_bandwidth,
-				   ricean_factor,
-				   aoa,
-				   forgetting_factor,
-				   maxDoppler,
-				   channel_offset, 
-				   path_loss_dB,
-				   0);
+                                   nb_rx,
+                                   nb_taps,
+                                   channel_length,
+                                   default_amp_lin,
+                                   NULL,
+                                   NULL,
+                                   Td,
+                                   sampling_rate,
+                                   channel_bandwidth,
+                                   ricean_factor,
+                                   aoa,
+                                   forgetting_factor,
+                                   maxDoppler,
+                                   channel_offset,
+                                   path_loss_dB,
+                                   0);
       break;
 
   case AWGN:
@@ -746,22 +746,22 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       maxDoppler = 0;
 
       fill_channel_desc(chan_desc,nb_tx,
-				   nb_rx,
-				   nb_taps,
-				   channel_length,
-				   default_amp_lin,
-				   NULL,
-				   NULL,
-				   Td,
-				   sampling_rate,
-				   channel_bandwidth,
-				   ricean_factor,
-				   aoa,
-				   forgetting_factor,
-				   maxDoppler,
-				   channel_offset, 
-				   path_loss_dB,
-				   0);
+                                   nb_rx,
+                                   nb_taps,
+                                   channel_length,
+                                   default_amp_lin,
+                                   NULL,
+                                   NULL,
+                                   Td,
+                                   sampling_rate,
+                                   channel_bandwidth,
+                                   ricean_factor,
+                                   aoa,
+                                   forgetting_factor,
+                                   maxDoppler,
+                                   channel_offset,
+                                   path_loss_dB,
+                                   0);
       printf("AWGN: ricean_factor %f\n",chan_desc->ricean_factor);
 
       break;
@@ -775,22 +775,22 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       maxDoppler = 0;
 
       fill_channel_desc(chan_desc,nb_tx,
-				   nb_rx,
-				   nb_taps,
-				   channel_length,
-				   ts_shift_amps,
-				   ts_shift_delays,
-				   NULL,
-				   Td,
-				   sampling_rate,
-				   channel_bandwidth,
-				   ricean_factor,
-				   aoa,
-				   forgetting_factor,
-				   maxDoppler,
-				   channel_offset, 
-				   path_loss_dB,
-				   0);
+                                   nb_rx,
+                                   nb_taps,
+                                   channel_length,
+                                   ts_shift_amps,
+                                   ts_shift_delays,
+                                   NULL,
+                                   Td,
+                                   sampling_rate,
+                                   channel_bandwidth,
+                                   ricean_factor,
+                                   aoa,
+                                   forgetting_factor,
+                                   maxDoppler,
+                                   channel_offset,
+                                   path_loss_dB,
+                                   0);
       printf("TS_SHIFT: ricean_factor %f\n",chan_desc->ricean_factor);
 
       break;
@@ -804,31 +804,31 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       maxDoppler = 0;
 
       if ((nb_tx==2) && (nb_rx==1)) {
-	R_sqrt_ptr2 = R_sqrt_21_corr;
+        R_sqrt_ptr2 = R_sqrt_21_corr;
       }
       else if ((nb_tx==2) && (nb_rx==2)) {
-	R_sqrt_ptr2 = R_sqrt_22_corr;
+        R_sqrt_ptr2 = R_sqrt_22_corr;
       }
       else
-	R_sqrt_ptr2 = NULL;
+        R_sqrt_ptr2 = NULL;
 
       fill_channel_desc(chan_desc,nb_tx,
-				   nb_rx,
-				   nb_taps,
-				   channel_length,
-				   default_amp_lin,
-				   NULL,
-				   R_sqrt_ptr2,
-				   Td,
-				   sampling_rate,
-				   channel_bandwidth,
-				   ricean_factor,
-				   aoa,
-				   forgetting_factor,
-				   maxDoppler,
-				   channel_offset, 
-				   path_loss_dB,
-				   1);
+                                   nb_rx,
+                                   nb_taps,
+                                   channel_length,
+                                   default_amp_lin,
+                                   NULL,
+                                   R_sqrt_ptr2,
+                                   Td,
+                                   sampling_rate,
+                                   channel_bandwidth,
+                                   ricean_factor,
+                                   aoa,
+                                   forgetting_factor,
+                                   maxDoppler,
+                                   channel_offset,
+                                   path_loss_dB,
+                                   1);
       break;
 
   case Rice1_anticorr:
@@ -840,33 +840,33 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       maxDoppler = 0;
 
       if ((nb_tx==2) && (nb_rx==1)) {
-	R_sqrt_ptr2 = R_sqrt_21_anticorr;
+        R_sqrt_ptr2 = R_sqrt_21_anticorr;
       }
       else if ((nb_tx==2) && (nb_rx==2)) {
-	R_sqrt_ptr2 = R_sqrt_22_anticorr;
+        R_sqrt_ptr2 = R_sqrt_22_anticorr;
       }
-      else 
-	R_sqrt_ptr2 = NULL;
+      else
+        R_sqrt_ptr2 = NULL;
 
       fill_channel_desc(chan_desc,nb_tx,
-				   nb_rx,
-				   nb_taps,
-				   channel_length,
-				   default_amp_lin,
-				   NULL,
-				   R_sqrt_ptr2,
-				   Td,
-				   sampling_rate,
-				   channel_bandwidth,
-				   ricean_factor,
-				   aoa,
-				   forgetting_factor,
-				   maxDoppler,
-				   channel_offset, 
-				   path_loss_dB,
-				   1);
+                                   nb_rx,
+                                   nb_taps,
+                                   channel_length,
+                                   default_amp_lin,
+                                   NULL,
+                                   R_sqrt_ptr2,
+                                   Td,
+                                   sampling_rate,
+                                   channel_bandwidth,
+                                   ricean_factor,
+                                   aoa,
+                                   forgetting_factor,
+                                   maxDoppler,
+                                   channel_offset,
+                                   path_loss_dB,
+                                   1);
       break;
-      
+
   case Rayleigh1_orthogonal:
       nb_taps = 1;
       Td = 0;
@@ -875,32 +875,32 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       aoa = 0.03;
       maxDoppler = 0;
 
-      
+
       if ((nb_tx==2) && (nb_rx==2)) {
-	R_sqrt_ptr2 = R_sqrt_22_orthogonal;
+        R_sqrt_ptr2 = R_sqrt_22_orthogonal;
       }
-      else 
-	R_sqrt_ptr2 = NULL;
+      else
+        R_sqrt_ptr2 = NULL;
 
       fill_channel_desc(chan_desc,nb_tx,
-				   nb_rx,
-				   nb_taps,
-				   channel_length,
-				   default_amp_lin,
-				   NULL,
-				   R_sqrt_ptr2,
-				   Td,
-				   sampling_rate,
-				   channel_bandwidth,
-				   ricean_factor,
-				   aoa,
-				   forgetting_factor,
-				   maxDoppler,
-				   channel_offset, 
-				   path_loss_dB,
-				   0);
+                                   nb_rx,
+                                   nb_taps,
+                                   channel_length,
+                                   default_amp_lin,
+                                   NULL,
+                                   R_sqrt_ptr2,
+                                   Td,
+                                   sampling_rate,
+                                   channel_bandwidth,
+                                   ricean_factor,
+                                   aoa,
+                                   forgetting_factor,
+                                   maxDoppler,
+                                   channel_offset,
+                                   path_loss_dB,
+                                   0);
       break;
-      
+
   case Rayleigh1_orth_eff_ch_TM4_prec_real:
       nb_taps = 1;
       Td = 0;
@@ -909,32 +909,32 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       aoa = 0.03;
       maxDoppler = 0;
 
-      
+
       if ((nb_tx==2) && (nb_rx==2)) {
-	R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_real; 
+        R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_real;
       }
-      else 
-	R_sqrt_ptr2 = NULL;
+      else
+        R_sqrt_ptr2 = NULL;
 
       fill_channel_desc(chan_desc,nb_tx,
-				   nb_rx,
-				   nb_taps,
-				   channel_length,
-				   default_amp_lin,
-				   NULL,
-				   R_sqrt_ptr2,
-				   Td,
-				   sampling_rate,
-				   channel_bandwidth,
-				   ricean_factor,
-				   aoa,
-				   forgetting_factor,
-				   maxDoppler,
-				   channel_offset, 
-				   path_loss_dB,
-				   1);
+                                   nb_rx,
+                                   nb_taps,
+                                   channel_length,
+                                   default_amp_lin,
+                                   NULL,
+                                   R_sqrt_ptr2,
+                                   Td,
+                                   sampling_rate,
+                                   channel_bandwidth,
+                                   ricean_factor,
+                                   aoa,
+                                   forgetting_factor,
+                                   maxDoppler,
+                                   channel_offset,
+                                   path_loss_dB,
+                                   1);
       break;
-      
+
       case Rayleigh1_orth_eff_ch_TM4_prec_imag:
       nb_taps = 1;
       Td = 0;
@@ -943,42 +943,42 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       aoa = 0.03;
       maxDoppler = 0;
 
-      
+
       if ((nb_tx==2) && (nb_rx==2)) {
-	R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_imag; 
+        R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_imag;
       }
-      else 
-	R_sqrt_ptr2 = NULL;
+      else
+        R_sqrt_ptr2 = NULL;
 
       fill_channel_desc(chan_desc,nb_tx,
-				   nb_rx,
-				   nb_taps,
-				   channel_length,
-				   default_amp_lin,
-				   NULL,
-				   R_sqrt_ptr2,
-				   Td,
-				   sampling_rate,
-				   channel_bandwidth,
-				   ricean_factor,
-				   aoa,
-				   forgetting_factor,
-				   maxDoppler,
-				   channel_offset, 
-				   path_loss_dB,
-				   0);
+                                   nb_rx,
+                                   nb_taps,
+                                   channel_length,
+                                   default_amp_lin,
+                                   NULL,
+                                   R_sqrt_ptr2,
+                                   Td,
+                                   sampling_rate,
+                                   channel_bandwidth,
+                                   ricean_factor,
+                                   aoa,
+                                   forgetting_factor,
+                                   maxDoppler,
+                                   channel_offset,
+                                   path_loss_dB,
+                                   0);
       break;
-      
+
        case Rayleigh8_orth_eff_ch_TM4_prec_real:
 
     if ((nb_tx==2) && (nb_rx==2)) {
-	R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_real; 
-	//R_sqrt_ptr2 = NULL;
+        R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_real;
+        //R_sqrt_ptr2 = NULL;
       }
-      else 
-	R_sqrt_ptr2 = NULL;
+      else
+        R_sqrt_ptr2 = NULL;
+
 
-    
       nb_taps = 8;
       Td = 0.8;
       channel_length = (int)11+2*sampling_rate*Td;
@@ -987,26 +987,26 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       maxDoppler = 0;
 
       fill_channel_desc(chan_desc,
-			nb_tx,
-			nb_rx,
-			nb_taps,
-			channel_length,
-			default_amps_lin,
-			NULL,
-			R_sqrt_ptr2,
-			Td,
-			sampling_rate,
-			channel_bandwidth,
-			ricean_factor,
-			aoa,
-			forgetting_factor,
-			maxDoppler,
-			channel_offset, 
-			path_loss_dB,
-			0);
-    
+                        nb_tx,
+                        nb_rx,
+                        nb_taps,
+                        channel_length,
+                        default_amps_lin,
+                        NULL,
+                        R_sqrt_ptr2,
+                        Td,
+                        sampling_rate,
+                        channel_bandwidth,
+                        ricean_factor,
+                        aoa,
+                        forgetting_factor,
+                        maxDoppler,
+                        channel_offset,
+                        path_loss_dB,
+                        0);
+
       break;
-      
+
       case Rayleigh8_orth_eff_ch_TM4_prec_imag:
       nb_taps = 8;
       Td = 0.8;
@@ -1016,31 +1016,31 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       maxDoppler = 0;
 
       if ((nb_tx==2) && (nb_rx==2)) {
-	R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_imag; 
+        R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_imag;
       }
-      else 
-	R_sqrt_ptr2 = NULL;
+      else
+        R_sqrt_ptr2 = NULL;
 
        fill_channel_desc(chan_desc,
-			nb_tx,
-			nb_rx,
-			nb_taps,
-			channel_length,
-			default_amps_lin,
-			NULL,
-			R_sqrt_ptr2,
-			Td,
-			sampling_rate,
-			channel_bandwidth,
-			ricean_factor,
-			aoa,
-			forgetting_factor,
-			maxDoppler,
-			channel_offset, 
-			path_loss_dB,
-			0);
+                        nb_tx,
+                        nb_rx,
+                        nb_taps,
+                        channel_length,
+                        default_amps_lin,
+                        NULL,
+                        R_sqrt_ptr2,
+                        Td,
+                        sampling_rate,
+                        channel_bandwidth,
+                        ricean_factor,
+                        aoa,
+                        forgetting_factor,
+                        maxDoppler,
+                        channel_offset,
+                        path_loss_dB,
+                        0);
       break;
-      
+
   default:
     LOG_W(OCM,"channel model not yet supported\n");
     free(chan_desc);
@@ -1057,12 +1057,12 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
 
 
 int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) {
-		    
+
   double s;
   int i,k,l,aarx,aatx;
   struct complex anew[NB_ANTENNAS_TX*NB_ANTENNAS_RX],acorr[NB_ANTENNAS_TX*NB_ANTENNAS_RX];
   struct complex phase, alpha, beta;
-  
+
   if ((desc->nb_tx>NB_ANTENNAS_TX) || (desc->nb_rx > NB_ANTENNAS_RX)) {
     msg("random_channel.c: Error: temporary buffer for channel not big enough (%d,%d)\n",desc->nb_tx,desc->nb_rx);
     return(-1);
@@ -1073,26 +1073,26 @@ int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) {
     for (aarx=0;aarx<desc->nb_rx;aarx++) {
       for (aatx=0;aatx<desc->nb_tx;aatx++) {
 
-	anew[aarx+(aatx*desc->nb_rx)].x = sqrt(desc->ricean_factor*desc->amps[i]/2) * gaussdouble(0.0,1.0);
-	anew[aarx+(aatx*desc->nb_rx)].y = sqrt(desc->ricean_factor*desc->amps[i]/2) * gaussdouble(0.0,1.0);
-
-	if ((i==0) && (desc->ricean_factor != 1.0)) {
-	  if (desc->random_aoa==1) {
-	    desc->aoa = uniformrandom()*2*M_PI;
-	  }
-
-	  // this assumes that both RX and TX have linear antenna arrays with lambda/2 antenna spacing. 
-	  // Furhter it is assumed that the arrays are parallel to each other and that they are far enough apart so 
-	  // that we can safely assume plane wave propagation.
-	  phase.x = cos(M_PI*((aarx-aatx)*sin(desc->aoa)));
-	  phase.y = sin(M_PI*((aarx-aatx)*sin(desc->aoa)));
-	  
-	  anew[aarx+(aatx*desc->nb_rx)].x += phase.x * sqrt(1.0-desc->ricean_factor);
-	  anew[aarx+(aatx*desc->nb_rx)].y += phase.y * sqrt(1.0-desc->ricean_factor);
-	}
+        anew[aarx+(aatx*desc->nb_rx)].x = sqrt(desc->ricean_factor*desc->amps[i]/2) * gaussdouble(0.0,1.0);
+        anew[aarx+(aatx*desc->nb_rx)].y = sqrt(desc->ricean_factor*desc->amps[i]/2) * gaussdouble(0.0,1.0);
+
+        if ((i==0) && (desc->ricean_factor != 1.0)) {
+          if (desc->random_aoa==1) {
+            desc->aoa = uniformrandom()*2*M_PI;
+          }
+
+          // this assumes that both RX and TX have linear antenna arrays with lambda/2 antenna spacing.
+          // Furhter it is assumed that the arrays are parallel to each other and that they are far enough apart so
+          // that we can safely assume plane wave propagation.
+          phase.x = cos(M_PI*((aarx-aatx)*sin(desc->aoa)));
+          phase.y = sin(M_PI*((aarx-aatx)*sin(desc->aoa)));
+
+          anew[aarx+(aatx*desc->nb_rx)].x += phase.x * sqrt(1.0-desc->ricean_factor);
+          anew[aarx+(aatx*desc->nb_rx)].y += phase.y * sqrt(1.0-desc->ricean_factor);
+        }
 #ifdef DEBUG_CH
-	printf("(%d,%d,%d) %f->(%f,%f) (%f,%f) phase (%f,%f)\n",aarx,aatx,i,desc->amps[i],anew[aarx+(aatx*desc->nb_rx)].x,anew[aarx+(aatx*desc->nb_rx)].y,desc->aoa,desc->ricean_factor,phase.x,phase.y);
-#endif	
+        printf("(%d,%d,%d) %f->(%f,%f) (%f,%f) phase (%f,%f)\n",aarx,aatx,i,desc->amps[i],anew[aarx+(aatx*desc->nb_rx)].x,anew[aarx+(aatx*desc->nb_rx)].y,desc->aoa,desc->ricean_factor,phase.x,phase.y);
+#endif
       } //aatx
     } //aarx
 
@@ -1100,9 +1100,9 @@ int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) {
     // for debugging set a=anew;
     for (aarx=0;aarx<desc->nb_rx;aarx++) {
       for (aatx=0;aatx<desc->nb_tx;aatx++) {
-	desc->a[i][aarx+(aatx*desc->nb_rx)].x = anew[aarx+(aatx*desc->nb_rx)].x;
-	desc->a[i][aarx+(aatx*desc->nb_rx)].y = anew[aarx+(aatx*desc->nb_rx)].y;
- 	printf("anew(%d,%d) = %f+1j*%f\n",aatx,aarx,anew[aarx+(aatx*desc->nb_rx)].x, anew[aarx+(aatx*desc->nb_rx)].y);
+        desc->a[i][aarx+(aatx*desc->nb_rx)].x = anew[aarx+(aatx*desc->nb_rx)].x;
+        desc->a[i][aarx+(aatx*desc->nb_rx)].y = anew[aarx+(aatx*desc->nb_rx)].y;
+        printf("anew(%d,%d) = %f+1j*%f\n",aatx,aarx,anew[aarx+(aatx*desc->nb_rx)].x, anew[aarx+(aatx*desc->nb_rx)].y);
      }
     }
     */
@@ -1113,16 +1113,16 @@ int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) {
     beta.x = 0.0;
     beta.y = 0.0;
 
-    cblas_zgemv(CblasRowMajor, CblasNoTrans, desc->nb_tx*desc->nb_rx, desc->nb_tx*desc->nb_rx, 
-		(void*) &alpha, (void*) desc->R_sqrt[i/3], desc->nb_rx*desc->nb_tx,
-		(void*) anew, 1, (void*) &beta, (void*) acorr, 1);
+    cblas_zgemv(CblasRowMajor, CblasNoTrans, desc->nb_tx*desc->nb_rx, desc->nb_tx*desc->nb_rx,
+                (void*) &alpha, (void*) desc->R_sqrt[i/3], desc->nb_rx*desc->nb_tx,
+                (void*) anew, 1, (void*) &beta, (void*) acorr, 1);
 
     /*
     for (aarx=0;aarx<desc->nb_rx;aarx++) {
       for (aatx=0;aatx<desc->nb_tx;aatx++) {
-	desc->a[i][aarx+(aatx*desc->nb_rx)].x = acorr[aarx+(aatx*desc->nb_rx)].x;
-	desc->a[i][aarx+(aatx*desc->nb_rx)].y = acorr[aarx+(aatx*desc->nb_rx)].y;
-	printf("tap %d, acorr1(%d,%d) = %f+1j*%f\n",i,aatx,aarx,acorr[aarx+(aatx*desc->nb_rx)].x, acorr[aarx+(aatx*desc->nb_rx)].y);
+        desc->a[i][aarx+(aatx*desc->nb_rx)].x = acorr[aarx+(aatx*desc->nb_rx)].x;
+        desc->a[i][aarx+(aatx*desc->nb_rx)].y = acorr[aarx+(aatx*desc->nb_rx)].y;
+        printf("tap %d, acorr1(%d,%d) = %f+1j*%f\n",i,aatx,aarx,acorr[aarx+(aatx*desc->nb_rx)].x, acorr[aarx+(aatx*desc->nb_rx)].y);
       }
     }
     */
@@ -1148,18 +1148,18 @@ int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) {
     /*
     for (aarx=0;aarx<desc->nb_rx;aarx++) {
       for (aatx=0;aatx<desc->nb_tx;aatx++) {
- 	//desc->a[i][aarx+(aatx*desc->nb_rx)].x = acorr[aarx+(aatx*desc->nb_rx)].x;
-	//desc->a[i][aarx+(aatx*desc->nb_rx)].y = acorr[aarx+(aatx*desc->nb_rx)].y;
-	printf("tap %d, a(%d,%d) = %f+1j*%f\n",i,aatx,aarx,desc->a[i][aarx+(aatx*desc->nb_rx)].x, desc->a[i][aarx+(aatx*desc->nb_rx)].y);
+        //desc->a[i][aarx+(aatx*desc->nb_rx)].x = acorr[aarx+(aatx*desc->nb_rx)].x;
+        //desc->a[i][aarx+(aatx*desc->nb_rx)].y = acorr[aarx+(aatx*desc->nb_rx)].y;
+        printf("tap %d, a(%d,%d) = %f+1j*%f\n",i,aatx,aarx,desc->a[i][aarx+(aatx*desc->nb_rx)].x, desc->a[i][aarx+(aatx*desc->nb_rx)].y);
       }
     }
     */
 
-  } //nb_taps      
+  } //nb_taps
   stop_meas(&desc->random_channel);
 
   //memset((void *)desc->ch[aarx+(aatx*desc->nb_rx)],0,(int)(desc->channel_length)*sizeof(struct complex));
-  
+
   if (abstraction_flag==0) {
     start_meas(&desc->interp_time);
 
@@ -1188,10 +1188,10 @@ int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) {
             } //nb_taps
 
 #ifdef DEBUG_CH
-	k=0;
-	printf("(%d,%d,%d)->(%f,%f)\n",k,aarx,aatx,desc->ch[aarx+(aatx*desc->nb_rx)][k].x,desc->ch[aarx+(aatx*desc->nb_rx)][k].y);
+        k=0;
+        printf("(%d,%d,%d)->(%f,%f)\n",k,aarx,aatx,desc->ch[aarx+(aatx*desc->nb_rx)][k].x,desc->ch[aarx+(aatx*desc->nb_rx)][k].y);
 #endif
-	}
+        }
       } //channel_length
     } //aatx
   } //aarx
@@ -1211,22 +1211,22 @@ double N_RB2sampling_rate(uint16_t N_RB)
   case 6:
     sampling_rate = 1.92;
     break;
-    
+
   case 25:
     sampling_rate = 7.68;
     break;
-    
+
   case 50:
     sampling_rate = 15.36;
     break;
-    
+
   case 100:
     sampling_rate = 30.72;
     break;
-    
+
   default:
     LOG_E(PHY,"Unknown N_PRB\n");
-    return(-1);  
+    return(-1);
   }
 
   return(sampling_rate);
@@ -1239,22 +1239,22 @@ double N_RB2channel_bandwidth(uint16_t N_RB)
   case 6:
     channel_bandwidth = 1.25;
     break;
-    
+
   case 25:
     channel_bandwidth = 5.00;
     break;
-    
+
   case 50:
     channel_bandwidth = 10.00;
     break;
-    
+
   case 100:
     channel_bandwidth = 20.00;
     break;
-    
+
   default:
     LOG_E(PHY,"Unknown N_PRB\n");
-    return(-1);  
+    return(-1);
   }
   return(channel_bandwidth);
 }
@@ -1267,7 +1267,7 @@ main(int argc,char **argv) {
   double amps[8] = {.8,.2,.1,.04,.02,.01,.005};
   struct complex ch[(int)(1+2*sampling_rate*Td)],phase;
   int i;
-  
+
   randominit();
   phase.x = 1.0;
   phase.y = 0;
diff --git a/openair1/SIMULATION/TOOLS/rangen_double.c b/openair1/SIMULATION/TOOLS/rangen_double.c
index d7d0543faea780d7fa01d992079dc1f7bfd4d3cc..6b98bbe7a7acd0d33c2b6732bc44d8ceb2ed7c13 100644
--- a/openair1/SIMULATION/TOOLS/rangen_double.c
+++ b/openair1/SIMULATION/TOOLS/rangen_double.c
@@ -46,7 +46,7 @@ static unsigned int seed, iy, ir[98];
 #define a 1664525lu
 #define mod 4294967296.0                /* is 2**32 */
 
-
+#if 1
 void randominit(unsigned seed_init)
 {
   int i;
@@ -69,17 +69,18 @@ void randominit(unsigned seed_init)
   }
 
  iy=1;
-} 
-
+}
+#endif
 
-/*void randominit(unsigned seed_init)
+#if 0
+void randominit(unsigned seed_init)
 {
   int i;
   // this need to be integrated with the existing rng, like taus: navid
   msg("Initializing random number generator, seed %x\n",seed_init);
 
   seed_init = 62110;
-  
+
   if (seed_init == 0) {
     srand((unsigned)time(NULL));
 
@@ -90,14 +91,14 @@ void randominit(unsigned seed_init)
 
   if (seed % 2 == 0) seed += 1; /* seed and mod are relative prime */
 
-//  for (i=1; i<=97; i++) {
-//    seed = a*seed;                 /* mod 2**32  */
-//    ir[i]= seed;                   /* initialize the shuffle table    */
-//  }
-
-//  iy=1;
-//}
+  for (i=1; i<=97; i++) {
+    seed = a*seed;                 /* mod 2**32  */
+    ir[i]= seed;                   /* initialize the shuffle table    */
+  }
 
+  iy=1;
+}
+#endif
 /*!\brief Uniform linear congruential random number generator on \f$[0,1)\f$.  Returns a double-precision floating-point number.*/
 
 double uniformrandom(void)
diff --git a/openair1/SIMULATION/TOOLS/taus.c b/openair1/SIMULATION/TOOLS/taus.c
index be2700d9430b3d910fdeee2183989e8eb0a29dd6..8ef3538867c2854016ce6847af8168d0cf9dd7c4 100644
--- a/openair1/SIMULATION/TOOLS/taus.c
+++ b/openair1/SIMULATION/TOOLS/taus.c
@@ -58,7 +58,7 @@ unsigned int taus(void)
   s2 = (((s2 & 0xFFFFFFF0) << 17)^  b);
   return s0 ^ s1 ^ s2;
 }
-
+#if 1
 void set_taus_seed(unsigned int seed_init)
 {
 
@@ -87,9 +87,11 @@ void set_taus_seed(unsigned int seed_init)
     s2 = result;
 #endif
   }
-} 
- 
-/* void set_taus_seed(unsigned int seed_init)
+}
+#endif
+
+#if 0
+ void set_taus_seed(unsigned int seed_init)
 {
 
 #ifdef USER_MODE
@@ -113,18 +115,17 @@ void set_taus_seed(unsigned int seed_init)
     s2 = (unsigned int)0xfe1a133e;
 #else
    // Use reentrant version of rand48 to ensure that no conflicts with other generators occur */
-  //  srand48_r((long int)seed_init, &buffer);
-  //  mrand48_r(&buffer, (long int *)&result);
-  //  s0 = result;
-  //  mrand48_r(&buffer, (long int *)&result);
-  //  s1 = result;
-  //  mrand48_r(&buffer, (long int *)&result);
-  //  s2 = result;
-//#endif
- // }
-//}
-
-    
+    srand48_r((long int)seed_init, &buffer);
+    mrand48_r(&buffer, (long int *)&result);
+    s0 = result;
+    mrand48_r(&buffer, (long int *)&result);
+    s1 = result;
+    mrand48_r(&buffer, (long int *)&result);
+    s2 = result;
+#endif
+  }
+}
+#endif
 
 #ifdef MAIN