From 857fd74e1b0becae283368b9e0ce5ecf5b640324 Mon Sep 17 00:00:00 2001
From: Florian Kaltenberger <florian.kaltenberger@eurecom.fr>
Date: Wed, 18 Nov 2015 13:44:46 +0100
Subject: [PATCH] commiting changes from svn branch SIC-receiver from revision
 6836 to 7896 (current svn head). See svn log for details.

---
 openair1/PHY/INIT/lte_init.c                  |   61 +-
 openair1/PHY/LTE_TRANSPORT/dci_tools.c        |  290 +-
 openair1/PHY/LTE_TRANSPORT/defs.h             |    6 +
 .../PHY/LTE_TRANSPORT/dlsch_demodulation.c    | 3982 +++++++++--------
 .../PHY/LTE_TRANSPORT/dlsch_llr_computation.c |   94 +-
 openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c |  215 +-
 openair1/PHY/LTE_TRANSPORT/power_control.c    |   25 +-
 openair1/PHY/LTE_TRANSPORT/proto.h            |   38 +-
 openair1/PHY/TOOLS/lte_phy_scope.c            |  208 +-
 openair1/PHY/TOOLS/lte_phy_scope.h            |    2 +
 openair1/PHY/impl_defs_lte.h                  |   21 +-
 openair1/SIMULATION/LTE_PHY/dlsim.c           | 1223 +++--
 openair1/SIMULATION/TOOLS/defs.h              |    8 +-
 openair1/SIMULATION/TOOLS/random_channel.c    |  246 +-
 openair2/UTIL/LOG/log.c                       |   64 +-
 15 files changed, 4003 insertions(+), 2480 deletions(-)

diff --git a/openair1/PHY/INIT/lte_init.c b/openair1/PHY/INIT/lte_init.c
index bdf35cccf99..6353f7fd7c4 100644
--- a/openair1/PHY/INIT/lte_init.c
+++ b/openair1/PHY/INIT/lte_init.c
@@ -882,33 +882,31 @@ void phy_init_lte_ue__PDSCH( LTE_UE_PDSCH* const pdsch, const LTE_DL_FRAME_PARMS
   pdsch->pmi_ext = (uint8_t*)malloc16_clear( frame_parms->N_RB_DL );
   pdsch->llr[0] = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) );
   pdsch->llr128 = (int16_t**)malloc16_clear( sizeof(int16_t*) );
-  pdsch->llr128_2ndstream = (int16_t**)malloc16_clear( sizeof(int16_t*) );
   // FIXME! no further allocation for (int16_t*)pdsch->llr128 !!! expect SIGSEGV
+  // FK, 11-3-2015: this is only as a temporary pointer, no memory is stored there
 
   pdsch->rxdataF_ext         = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
   pdsch->rxdataF_comp0       = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
-  pdsch->rho                 = (int32_t**)malloc16_clear( frame_parms->nb_antennas_rx*sizeof(int32_t*) );
   pdsch->dl_ch_estimates_ext = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
-  pdsch->dl_ch_rho_ext       = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
-  pdsch->dl_ch_rho2_ext       = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
   pdsch->dl_ch_mag0          = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
   pdsch->dl_ch_magb0         = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  pdsch->dl_ch_mag1          = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+  pdsch->dl_ch_magb1         = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
 
   // the allocated memory size is fixed:
   AssertFatal( frame_parms->nb_antennas_rx <= 2, "nb_antennas_rx > 2" );
 
   for (int i=0; i<frame_parms->nb_antennas_rx; i++) {
-    pdsch->rho[i]     = (int32_t*)malloc16_clear( sizeof(int32_t)*(frame_parms->N_RB_DL*12*7*2) );
     for (int j=0; j<4; j++) { //frame_parms->nb_antennas_tx; j++)
       const int idx = (j<<1)+i;
-      const size_t num = 7*2*frame_parms->N_RB_DL*12;
+      const size_t num = 7*2*frame_parms->N_RB_DL*12+4;
       pdsch->rxdataF_ext[idx]         = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
       pdsch->rxdataF_comp0[idx]       = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
       pdsch->dl_ch_estimates_ext[idx] = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
-      pdsch->dl_ch_rho_ext[idx]       = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
-      pdsch->dl_ch_rho2_ext[idx]       = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
       pdsch->dl_ch_mag0[idx]          = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
       pdsch->dl_ch_magb0[idx]         = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      pdsch->dl_ch_mag1[idx]          = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+      pdsch->dl_ch_magb1[idx]         = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
     }
   }
 }
@@ -943,7 +941,7 @@ void phy_init_lte_ue__PDSCH_FLP( LTE_UE_PDSCH_FLP* const pdsch_flp, const LTE_DL
       pdsch_flp->rho[i] = (double*)malloc16_clear( sizeof(double)*(frame_parms->N_RB_DL*12*7*2) );
       for (int j=0; j<4; j++) { //frame_parms->nb_antennas_tx; j++)
           const int idx = (j<<1)+i;
-          const size_t num = 7*2*frame_parms->N_RB_DL*12;
+          const size_t num = 7*2*frame_parms->N_RB_DL*12+4;
           pdsch_flp->rxdataF_ext[idx]         = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
           pdsch_flp->dl_ch_estimates_ext[idx] = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
           pdsch_flp->rxdataF_comp[idx]        = (double*)malloc16_clear( sizeof(double) * num );
@@ -970,7 +968,7 @@ int phy_init_lte_ue(PHY_VARS_UE *phy_vars_ue,
   LTE_UE_PDCCH** const ue_pdcch_vars         = phy_vars_ue->lte_ue_pdcch_vars;
   LTE_UE_PRACH** const ue_prach_vars         = phy_vars_ue->lte_ue_prach_vars;
 
-  int i,j,k;
+  int i,j,k,l;
   int eNB_id;
 
   msg("Initializing UE vars (abstraction %"PRIu8") for eNB TXant %"PRIu8", UE RXant %"PRIu8"\n",abstraction_flag,frame_parms->nb_antennas_tx,frame_parms->nb_antennas_rx);
@@ -1064,25 +1062,42 @@ int phy_init_lte_ue(PHY_VARS_UE *phy_vars_ue,
     ue_pbch_vars[eNB_id]      = (LTE_UE_PBCH *)malloc16_clear(sizeof(LTE_UE_PBCH));
 
     if (abstraction_flag == 0) {
+      // init basic (common) variables
       phy_init_lte_ue__PDSCH( ue_pdsch_vars[eNB_id], frame_parms );
 
-      ue_pdsch_vars[eNB_id]->llr_shifts   = (uint8_t*)malloc16_clear(7*2*frame_parms->N_RB_DL*12);
-      ue_pdsch_vars[eNB_id]->llr_shifts_p = ue_pdsch_vars[eNB_id]->llr_shifts;
-      ue_pdsch_vars[eNB_id]->dl_ch_mag1   = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
-      ue_pdsch_vars[eNB_id]->dl_ch_magb1  = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
-      ue_pdsch_vars[eNB_id]->llr[1]       = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) );
+      // init variables only needed for standard PDSCH
+      ue_pdsch_vars[eNB_id]->llr_shifts          = (uint8_t*)malloc16_clear(7*2*frame_parms->N_RB_DL*12);
+      ue_pdsch_vars[eNB_id]->llr_shifts_p        = ue_pdsch_vars[eNB_id]->llr_shifts;
+      ue_pdsch_vars[eNB_id]->llr[1]              = (int16_t*)malloc16_clear( (8*((3*8*6144)+12))*sizeof(int16_t) );
+      ue_pdsch_vars[eNB_id]->llr128_2ndstream    = (int16_t**)malloc16_clear( sizeof(int16_t*) );
 
-      for (k=0;k<8;k++)
-        ue_pdsch_vars[eNB_id]->rxdataF_comp1[k] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+      ue_pdsch_vars[eNB_id]->rho                 = (int32_t**)malloc16_clear( frame_parms->nb_antennas_rx*sizeof(int32_t*) );
+      for (int i=0; i<frame_parms->nb_antennas_rx; i++) 
+	ue_pdsch_vars[eNB_id]->rho[i]     = (int32_t*)malloc16_clear( sizeof(int32_t)*(frame_parms->N_RB_DL*12*7*2) );
+
+      ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext      = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
       for (i=0; i<frame_parms->nb_antennas_rx; i++)
         for (j=0; j<4;j++) {
-          int idx = (j<<1)+i;
-          ue_pdsch_vars[eNB_id]->dl_ch_mag1[idx]  = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(frame_parms->N_RB_DL*12) );
-          ue_pdsch_vars[eNB_id]->dl_ch_magb1[idx] = (int32_t*)malloc16_clear( 7*2*sizeof(int32_t)*(frame_parms->N_RB_DL*12) );
-          for (k=0;k<8;k++)
-            ue_pdsch_vars[eNB_id]->rxdataF_comp1[idx][k] = (int32_t*)malloc16_clear( sizeof(int32_t)*(frame_parms->N_RB_DL*12*14) );
+          const int idx = (j<<1)+i;
+	  const size_t num = 7*2*frame_parms->N_RB_DL*12+4;
+	  ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext[idx] = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
 	}
 
+      for (k=0;k<8;k++) { //harq_pid
+	for (l=0;l<8;l++) { //round
+	  ue_pdsch_vars[eNB_id]->rxdataF_comp1[k][l] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+	  ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[k][l] = (int32_t**)malloc16_clear( 8*sizeof(int32_t*) );
+	      
+	  for (int i=0; i<frame_parms->nb_antennas_rx; i++) 
+	    for (int j=0; j<4; j++) { //frame_parms->nb_antennas_tx; j++)
+	      const int idx = (j<<1)+i;
+	      const size_t num = 7*2*frame_parms->N_RB_DL*12+4;
+	      ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[k][l][idx] = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+	      ue_pdsch_vars[eNB_id]->rxdataF_comp1[k][l][idx] = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
+	    }
+	}
+      }
+
 #ifdef ENABLE_FULL_FLP
       phy_init_lte_ue__PDSCH_FLP( ue_pdsch_vars_flp[eNB_id], frame_parms );
 #endif
@@ -1106,7 +1121,7 @@ int phy_init_lte_ue(PHY_VARS_UE *phy_vars_ue,
         ue_pdcch_vars[eNB_id]->rho[i] = (int32_t*)malloc16_clear( sizeof(int32_t)*(frame_parms->N_RB_DL*12*7*2) );
         for (j=0; j<4;j++) {//frame_parms->nb_antennas_tx; j++)
           int idx = (j<<1)+i;
-          size_t num = 7*2*frame_parms->N_RB_DL*12;
+          size_t num = 7*2*frame_parms->N_RB_DL*12+4;
           ue_pdcch_vars[eNB_id]->rxdataF_comp[idx]        = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
           ue_pdcch_vars[eNB_id]->dl_ch_rho_ext[idx]       = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
           ue_pdcch_vars[eNB_id]->rxdataF_ext[idx]         = (int32_t*)malloc16_clear( sizeof(int32_t) * num );
diff --git a/openair1/PHY/LTE_TRANSPORT/dci_tools.c b/openair1/PHY/LTE_TRANSPORT/dci_tools.c
index 1ccb3196fce..fc4173f4990 100644
--- a/openair1/PHY/LTE_TRANSPORT/dci_tools.c
+++ b/openair1/PHY/LTE_TRANSPORT/dci_tools.c
@@ -1217,26 +1217,28 @@ int generate_eNB_dlsch_params_from_dci(uint8_t subframe,
 
     if (frame_parms->nb_antennas_tx == 2) {
       if (dlsch1->active == 1) { // both TBs are active
+      dlsch0_harq->dl_power_off = 1; //no power offset??
+      dlsch1_harq->dl_power_off = 1; //no power offset??
 	dlsch0_harq->TBS         = TBStable[get_I_TBS(dlsch0_harq->mcs)][dlsch0_harq->nb_rb-1];
 	dlsch1_harq->TBS         = TBStable[get_I_TBS(dlsch1_harq->mcs)][dlsch0_harq->nb_rb-1];
 	switch (tpmi) {
 	case 0:
-	  dlsch0_harq->mimo_mode   = UNIFORM_PRECODING11;
-	  dlsch1_harq->mimo_mode   = UNIFORM_PRECODING1m1;
-	  dlsch0_harq->pmi_alloc                             = pmi_extend(frame_parms,0);
-	  dlsch1_harq->pmi_alloc                             = pmi_extend(frame_parms,1);
+	  dlsch0_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODING1;
+	  dlsch1_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODING1;
+	  dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,0);
+	  dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,1);
 	  break;
 	case 1:
-	  dlsch0_harq->mimo_mode   = UNIFORM_PRECODING1j;
-	  dlsch1_harq->mimo_mode   = UNIFORM_PRECODING1mj;
-	  dlsch0_harq->pmi_alloc                             = pmi_extend(frame_parms,2);
-	  dlsch0_harq->pmi_alloc                             = pmi_extend(frame_parms,3);
+	  dlsch0_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODINGj;
+	  dlsch1_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODINGj;
+	  dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,2);
+	  dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,3);
 	  break;
 	case 2: // PUSCH precoding
 	  dlsch0_harq->mimo_mode   = DUALSTREAM_PUSCH_PRECODING;
-	  dlsch0_harq->pmi_alloc                             = DL_pmi_single;
+	  dlsch0_harq->pmi_alloc   = DL_pmi_single;
 	  dlsch1_harq->mimo_mode   = DUALSTREAM_PUSCH_PRECODING;
-	  dlsch1_harq->pmi_alloc                             = DL_pmi_single;
+	  dlsch1_harq->pmi_alloc   = DL_pmi_single;
 	  break;
 	default:
 	  break;
@@ -1245,6 +1247,7 @@ int generate_eNB_dlsch_params_from_dci(uint8_t subframe,
 	dlsch1_harq->TBS         = TBStable[get_I_TBS(dlsch1_harq->mcs)][dlsch1_harq->nb_rb-1];
       }
       else { // only one is active
+	dlsch0_harq->dl_power_off = 1; //???
 	switch (tpmi) {
 	case 0 :
 	  dlsch0_harq->mimo_mode   = ALAMOUTI;
@@ -1292,8 +1295,8 @@ int generate_eNB_dlsch_params_from_dci(uint8_t subframe,
     dlsch0->rnti = rnti;
     dlsch1->rnti = rnti;
 
-    dlsch0_harq->dl_power_off = 0;
-    dlsch1_harq->dl_power_off = 0;
+   // dlsch0_harq->dl_power_off = 1;
+  // dlsch1_harq->dl_power_off = 1;
 
     break;
 
@@ -1513,7 +1516,7 @@ int generate_eNB_dlsch_params_from_dci(uint8_t subframe,
 
     // Flip the TB to codeword mapping as described in 5.3.3.1.5 of 36-212 V11.3.0
     // note that we must set tbswap=0 in eNB scheduler if one TB is deactivated
-    if (tbswap == 0) {
+    if (tbswap == 0) { 
       dlsch0 = dlsch[0];
       dlsch1 = dlsch[1];
     }
@@ -1568,25 +1571,27 @@ int generate_eNB_dlsch_params_from_dci(uint8_t subframe,
       dlsch1->active = 0;
     }
 
-    dlsch0_harq->dl_power_off = 0;
-    dlsch1_harq->dl_power_off = 0;
+   // dlsch0_harq->dl_power_off = 0;
+   // dlsch1_harq->dl_power_off = 0;
 
 
     if (frame_parms->nb_antennas_tx == 2) {
       dlsch0_harq->TBS         = TBStable[get_I_TBS(dlsch0_harq->mcs)][dlsch0_harq->nb_rb-1];
       dlsch1_harq->TBS         = TBStable[get_I_TBS(dlsch1_harq->mcs)][dlsch0_harq->nb_rb-1];
       if ((dlsch0->active==1) && (dlsch1->active==1)) {
+	
 	dlsch0_harq->mimo_mode = LARGE_CDD;
 	dlsch1_harq->mimo_mode = LARGE_CDD;
 	dlsch0_harq->dl_power_off = 1;
 	dlsch1_harq->dl_power_off = 1;
       }
       else {
+	dlsch0_harq->dl_power_off = 1; 
 	dlsch0_harq->mimo_mode   = ALAMOUTI;
 	dlsch1_harq->mimo_mode   = ALAMOUTI;
       }
     }
-    else if (frame_parms->nb_antennas_tx == 4) { // 4 antenna case
+    else if (frame_parms->nb_antennas_tx == 4) {
       if ((dlsch0->active==1) && (dlsch1->active==1)) {
 	switch (tpmi) {
 	case 0: // one layer per transport block
@@ -1629,6 +1634,7 @@ int generate_eNB_dlsch_params_from_dci(uint8_t subframe,
 	case 0: // one layer per transport block
 	  dlsch0_harq->mimo_mode   = ALAMOUTI;
 	  dlsch1_harq->mimo_mode   = ALAMOUTI;
+	  dlsch0_harq->dl_power_off = 1;
 	  dlsch0_harq->TBS         = TBStable[get_I_TBS(dlsch0_harq->mcs)][dlsch0_harq->nb_rb-1];
 	  break;
 	case 1: // two-layers on TB 0
@@ -1648,6 +1654,7 @@ int generate_eNB_dlsch_params_from_dci(uint8_t subframe,
 	case 0: // one layer per transport block
 	  dlsch0_harq->mimo_mode   = ALAMOUTI;
 	  dlsch1_harq->mimo_mode   = ALAMOUTI;
+	  dlsch1_harq->dl_power_off = 1;
 	  dlsch1_harq->TBS         = TBStable[get_I_TBS(dlsch1_harq->mcs)][dlsch1_harq->nb_rb-1];
 	  break;
 	case 1: // two-layers on TB 0
@@ -2316,7 +2323,7 @@ int generate_eNB_dlsch_params_from_dci(uint8_t subframe,
 #endif
 
   // compute DL power control parameters   
-  computeRhoA_eNB(pdsch_config_dedicated, dlsch[0],dlsch0_harq->dl_power_off);
+  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);
 
@@ -3737,12 +3744,9 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 
     dlsch0_harq->dl_power_off = 1; //no power offset
 
-    LOG_D(PHY,"UE (%x/%d): Subframe %d Format2 DCI: ndi %d, old_ndi %d (first tx %d) harq_status %d\n",dlsch[0]->rnti,harq_pid,subframe,ndi,dlsch0_harq->DCINdi,
+    LOG_D(PHY,"UE (%x/%d): Subframe %d Format1 DCI: ndi %d, old_ndi %d (first tx %d) harq_status %d\n",dlsch[0]->rnti,harq_pid,subframe,ndi,dlsch0_harq->DCINdi,
 	  dlsch0_harq->first_tx,dlsch0_harq->status);
 
-    //    printf("Format2 DCI (UE, hard pid %d): ndi %d, old_ndi %d (first tx %d)\n",harq_pid,ndi,dlsch0_harq->DCINdi,
-    //	  dlsch0_harq->first_tx);
-    
     if ((ndi!=dlsch0_harq->DCINdi)||
 	(dlsch0_harq->first_tx==1)) {
       //    printf("Rate: setting round to zero (ndi %d, DCINdi %d,first_tx %d)\n",ndi,dlsch0_harq->DCINdi,dlsch0_harq->first_tx);
@@ -3750,7 +3754,7 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
       dlsch0_harq->status = ACTIVE;
       dlsch0_harq->DCINdi = ndi;
       if (dlsch0_harq->first_tx==1) {
-	LOG_D(PHY,"[PDSCH %x/%d] Format 1 DCI First TX: Clearing flag\n");
+	LOG_D(PHY,"Format 1 DCI First TX: Clearing flag\n");
 	dlsch0_harq->first_tx = 0;
       }
     }
@@ -3792,6 +3796,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	  rballoc   = ((DCI2_1_5MHz_2A_TDD_t *)dci_pdu)->rballoc;
 	  rv1       = ((DCI2_1_5MHz_2A_TDD_t *)dci_pdu)->rv1;
 	  rv2       = ((DCI2_1_5MHz_2A_TDD_t *)dci_pdu)->rv2;
+	  ndi1      = ((DCI2_1_5MHz_2A_TDD_t *)dci_pdu)->ndi1;
+	  ndi2      = ((DCI2_1_5MHz_2A_TDD_t *)dci_pdu)->ndi2;
 	  harq_pid  = ((DCI2_1_5MHz_2A_TDD_t *)dci_pdu)->harq_pid;
 	  tbswap    = ((DCI2_1_5MHz_2A_TDD_t *)dci_pdu)->tb_swap;
 	  tpmi      = ((DCI2_1_5MHz_2A_TDD_t *)dci_pdu)->tpmi;
@@ -3802,6 +3808,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	  rballoc   = ((DCI2_1_5MHz_2A_FDD_t *)dci_pdu)->rballoc;
 	  rv1       = ((DCI2_1_5MHz_2A_FDD_t *)dci_pdu)->rv1;
 	  rv2       = ((DCI2_1_5MHz_2A_FDD_t *)dci_pdu)->rv2;
+	  ndi1      = ((DCI2_1_5MHz_2A_FDD_t *)dci_pdu)->ndi1;
+	  ndi2      = ((DCI2_1_5MHz_2A_FDD_t *)dci_pdu)->ndi2;
 	  harq_pid  = ((DCI2_1_5MHz_2A_FDD_t *)dci_pdu)->harq_pid;
 	  tbswap    = ((DCI2_1_5MHz_2A_FDD_t *)dci_pdu)->tb_swap;
 	  tpmi      = ((DCI2_1_5MHz_2A_FDD_t *)dci_pdu)->tpmi;
@@ -3814,6 +3822,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	  rballoc   = ((DCI2_1_5MHz_4A_TDD_t *)dci_pdu)->rballoc;
 	  rv1       = ((DCI2_1_5MHz_4A_TDD_t *)dci_pdu)->rv1;
 	  rv2       = ((DCI2_1_5MHz_4A_TDD_t *)dci_pdu)->rv2;
+	  ndi1      = ((DCI2_1_5MHz_4A_TDD_t *)dci_pdu)->ndi1;
+	  ndi2      = ((DCI2_1_5MHz_4A_TDD_t *)dci_pdu)->ndi2;
 	  harq_pid  = ((DCI2_1_5MHz_4A_TDD_t *)dci_pdu)->harq_pid;
 	  tbswap    = ((DCI2_1_5MHz_4A_TDD_t *)dci_pdu)->tb_swap;
 	  tpmi      = ((DCI2_1_5MHz_4A_TDD_t *)dci_pdu)->tpmi;
@@ -3824,6 +3834,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	  rballoc   = ((DCI2_1_5MHz_4A_FDD_t *)dci_pdu)->rballoc;
 	  rv1       = ((DCI2_1_5MHz_4A_FDD_t *)dci_pdu)->rv1;
 	  rv2       = ((DCI2_1_5MHz_4A_FDD_t *)dci_pdu)->rv2;
+	  ndi1      = ((DCI2_1_5MHz_4A_FDD_t *)dci_pdu)->ndi1;
+	  ndi2      = ((DCI2_1_5MHz_4A_FDD_t *)dci_pdu)->ndi2;
 	  harq_pid  = ((DCI2_1_5MHz_4A_FDD_t *)dci_pdu)->harq_pid;
 	  tbswap    = ((DCI2_1_5MHz_4A_FDD_t *)dci_pdu)->tb_swap;
 	  tpmi      = ((DCI2_1_5MHz_4A_FDD_t *)dci_pdu)->tpmi;
@@ -3842,6 +3854,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	  rah       = ((DCI2_5MHz_2A_TDD_t *)dci_pdu)->rah;
 	  rv1       = ((DCI2_5MHz_2A_TDD_t *)dci_pdu)->rv1;
 	  rv2       = ((DCI2_5MHz_2A_TDD_t *)dci_pdu)->rv2;
+	  ndi1      = ((DCI2_5MHz_2A_TDD_t *)dci_pdu)->ndi1;
+	  ndi2      = ((DCI2_5MHz_2A_TDD_t *)dci_pdu)->ndi2;
 	  harq_pid  = ((DCI2_5MHz_2A_TDD_t *)dci_pdu)->harq_pid;
 	  tbswap    = ((DCI2_5MHz_2A_TDD_t *)dci_pdu)->tb_swap;
 	  tpmi      = ((DCI2_5MHz_2A_TDD_t *)dci_pdu)->tpmi;
@@ -3853,6 +3867,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	  rah       = ((DCI2_5MHz_2A_FDD_t *)dci_pdu)->rah;
 	  rv1       = ((DCI2_5MHz_2A_FDD_t *)dci_pdu)->rv1;
 	  rv2       = ((DCI2_5MHz_2A_FDD_t *)dci_pdu)->rv2;
+	  ndi1      = ((DCI2_5MHz_2A_FDD_t *)dci_pdu)->ndi1;
+	  ndi2      = ((DCI2_5MHz_2A_FDD_t *)dci_pdu)->ndi2;
 	  harq_pid  = ((DCI2_5MHz_2A_FDD_t *)dci_pdu)->harq_pid;
 	  tbswap    = ((DCI2_5MHz_2A_FDD_t *)dci_pdu)->tb_swap;
 	  tpmi      = ((DCI2_5MHz_2A_FDD_t *)dci_pdu)->tpmi;
@@ -3866,6 +3882,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	  rah       = ((DCI2_5MHz_4A_TDD_t *)dci_pdu)->rah;
 	  rv1       = ((DCI2_5MHz_4A_TDD_t *)dci_pdu)->rv1;
 	  rv2       = ((DCI2_5MHz_4A_TDD_t *)dci_pdu)->rv2;
+	  ndi1      = ((DCI2_5MHz_4A_TDD_t *)dci_pdu)->ndi1;
+	  ndi2      = ((DCI2_5MHz_4A_TDD_t *)dci_pdu)->ndi2;
 	  harq_pid  = ((DCI2_5MHz_4A_TDD_t *)dci_pdu)->harq_pid;
 	  tbswap    = ((DCI2_5MHz_4A_TDD_t *)dci_pdu)->tb_swap;
 	  tpmi      = ((DCI2_5MHz_4A_TDD_t *)dci_pdu)->tpmi;
@@ -3877,6 +3895,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	  rah       = ((DCI2_5MHz_4A_FDD_t *)dci_pdu)->rah;
 	  rv1       = ((DCI2_5MHz_4A_FDD_t *)dci_pdu)->rv1;
 	  rv2       = ((DCI2_5MHz_4A_FDD_t *)dci_pdu)->rv2;
+	  ndi1      = ((DCI2_5MHz_4A_FDD_t *)dci_pdu)->ndi1;
+	  ndi2      = ((DCI2_5MHz_4A_FDD_t *)dci_pdu)->ndi2;
 	  harq_pid  = ((DCI2_5MHz_4A_FDD_t *)dci_pdu)->harq_pid;
 	  tbswap    = ((DCI2_5MHz_4A_FDD_t *)dci_pdu)->tb_swap;
 	  tpmi      = ((DCI2_5MHz_4A_FDD_t *)dci_pdu)->tpmi;
@@ -3895,6 +3915,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	  rah       = ((DCI2_10MHz_2A_TDD_t *)dci_pdu)->rah;
 	  rv1       = ((DCI2_10MHz_2A_TDD_t *)dci_pdu)->rv1;
 	  rv2       = ((DCI2_10MHz_2A_TDD_t *)dci_pdu)->rv2;
+	  ndi1      = ((DCI2_10MHz_2A_TDD_t *)dci_pdu)->ndi1;
+	  ndi2      = ((DCI2_10MHz_2A_TDD_t *)dci_pdu)->ndi2;
 	  harq_pid  = ((DCI2_10MHz_2A_TDD_t *)dci_pdu)->harq_pid;
 	  tbswap    = ((DCI2_10MHz_2A_TDD_t *)dci_pdu)->tb_swap;
 	  tpmi      = ((DCI2_10MHz_2A_TDD_t *)dci_pdu)->tpmi;
@@ -3906,6 +3928,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	  rah       = ((DCI2_10MHz_2A_FDD_t *)dci_pdu)->rah;
 	  rv1       = ((DCI2_10MHz_2A_FDD_t *)dci_pdu)->rv1;
 	  rv2       = ((DCI2_10MHz_2A_FDD_t *)dci_pdu)->rv2;
+	  ndi1      = ((DCI2_10MHz_2A_FDD_t *)dci_pdu)->ndi1;
+	  ndi2      = ((DCI2_10MHz_2A_FDD_t *)dci_pdu)->ndi2;
 	  harq_pid  = ((DCI2_10MHz_2A_FDD_t *)dci_pdu)->harq_pid;
 	  tbswap    = ((DCI2_10MHz_2A_FDD_t *)dci_pdu)->tb_swap;
 	  tpmi      = ((DCI2_10MHz_2A_FDD_t *)dci_pdu)->tpmi;
@@ -3919,6 +3943,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	  rah       = ((DCI2_10MHz_4A_TDD_t *)dci_pdu)->rah;
 	  rv1       = ((DCI2_10MHz_4A_TDD_t *)dci_pdu)->rv1;
 	  rv2       = ((DCI2_10MHz_4A_TDD_t *)dci_pdu)->rv2;
+	  ndi1      = ((DCI2_10MHz_4A_TDD_t *)dci_pdu)->ndi1;
+	  ndi2      = ((DCI2_10MHz_4A_TDD_t *)dci_pdu)->ndi2;
 	  harq_pid  = ((DCI2_10MHz_4A_TDD_t *)dci_pdu)->harq_pid;
 	  tbswap    = ((DCI2_10MHz_4A_TDD_t *)dci_pdu)->tb_swap;
 	  tpmi      = ((DCI2_10MHz_4A_TDD_t *)dci_pdu)->tpmi;
@@ -3930,6 +3956,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	  rah       = ((DCI2_10MHz_4A_FDD_t *)dci_pdu)->rah;
 	  rv1       = ((DCI2_10MHz_4A_FDD_t *)dci_pdu)->rv1;
 	  rv2       = ((DCI2_10MHz_4A_FDD_t *)dci_pdu)->rv2;
+	  ndi1      = ((DCI2_10MHz_4A_FDD_t *)dci_pdu)->ndi1;
+	  ndi2      = ((DCI2_10MHz_4A_FDD_t *)dci_pdu)->ndi2;
 	  harq_pid  = ((DCI2_10MHz_4A_FDD_t *)dci_pdu)->harq_pid;
 	  tbswap    = ((DCI2_10MHz_4A_FDD_t *)dci_pdu)->tb_swap;
 	  tpmi      = ((DCI2_10MHz_4A_FDD_t *)dci_pdu)->tpmi;
@@ -3949,6 +3977,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	  rah       = ((DCI2_20MHz_2A_TDD_t *)dci_pdu)->rah;
 	  rv1       = ((DCI2_20MHz_2A_TDD_t *)dci_pdu)->rv1;
 	  rv2       = ((DCI2_20MHz_2A_TDD_t *)dci_pdu)->rv2;
+	  ndi1      = ((DCI2_20MHz_2A_TDD_t *)dci_pdu)->ndi1;
+	  ndi2      = ((DCI2_20MHz_2A_TDD_t *)dci_pdu)->ndi2;
 	  harq_pid  = ((DCI2_20MHz_2A_TDD_t *)dci_pdu)->harq_pid;
 	  tbswap    = ((DCI2_20MHz_2A_TDD_t *)dci_pdu)->tb_swap;
 	  tpmi      = ((DCI2_20MHz_2A_TDD_t *)dci_pdu)->tpmi;
@@ -3960,6 +3990,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	  rah       = ((DCI2_20MHz_2A_FDD_t *)dci_pdu)->rah;
 	  rv1       = ((DCI2_20MHz_2A_FDD_t *)dci_pdu)->rv1;
 	  rv2       = ((DCI2_20MHz_2A_FDD_t *)dci_pdu)->rv2;
+	  ndi1      = ((DCI2_20MHz_2A_FDD_t *)dci_pdu)->ndi1;
+	  ndi2      = ((DCI2_20MHz_2A_FDD_t *)dci_pdu)->ndi2;
 	  harq_pid  = ((DCI2_20MHz_2A_FDD_t *)dci_pdu)->harq_pid;
 	  tbswap    = ((DCI2_20MHz_2A_FDD_t *)dci_pdu)->tb_swap;
 	  tpmi      = ((DCI2_20MHz_2A_FDD_t *)dci_pdu)->tpmi;
@@ -3973,6 +4005,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	  rah       = ((DCI2_20MHz_4A_TDD_t *)dci_pdu)->rah;
 	  rv1       = ((DCI2_20MHz_4A_TDD_t *)dci_pdu)->rv1;
 	  rv2       = ((DCI2_20MHz_4A_TDD_t *)dci_pdu)->rv2;
+	  ndi1      = ((DCI2_20MHz_4A_TDD_t *)dci_pdu)->ndi1;
+	  ndi2      = ((DCI2_20MHz_4A_TDD_t *)dci_pdu)->ndi2;
 	  harq_pid  = ((DCI2_20MHz_4A_TDD_t *)dci_pdu)->harq_pid;
 	  tbswap    = ((DCI2_20MHz_4A_TDD_t *)dci_pdu)->tb_swap;
 	  tpmi      = ((DCI2_20MHz_4A_TDD_t *)dci_pdu)->tpmi;
@@ -3984,6 +4018,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	  rah       = ((DCI2_20MHz_4A_FDD_t *)dci_pdu)->rah;
 	  rv1       = ((DCI2_20MHz_4A_FDD_t *)dci_pdu)->rv1;
 	  rv2       = ((DCI2_20MHz_4A_FDD_t *)dci_pdu)->rv2;
+	  ndi1      = ((DCI2_20MHz_4A_FDD_t *)dci_pdu)->ndi1;
+	  ndi2      = ((DCI2_20MHz_4A_FDD_t *)dci_pdu)->ndi2;
 	  harq_pid  = ((DCI2_20MHz_4A_FDD_t *)dci_pdu)->harq_pid;
 	  tbswap    = ((DCI2_20MHz_4A_FDD_t *)dci_pdu)->tb_swap;
 	  tpmi      = ((DCI2_20MHz_4A_FDD_t *)dci_pdu)->tpmi;
@@ -4001,9 +4037,6 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
     }
 
 
-    dlsch[0]->current_harq_pid = harq_pid;
-    dlsch[0]->harq_ack[subframe].harq_id = harq_pid;
-
     tbswap = ((DCI2_5MHz_2A_TDD_t *)dci_pdu)->tb_swap;
     if (tbswap == 0) {
       dlsch0 = dlsch[0];
@@ -4016,114 +4049,166 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 
     dlsch0_harq = dlsch0->harq_processes[harq_pid];
     dlsch1_harq = dlsch1->harq_processes[harq_pid];
+    dlsch0->current_harq_pid = harq_pid;
+    dlsch1->current_harq_pid = harq_pid;
+    dlsch0->harq_ack[subframe].harq_id = harq_pid;
+    dlsch1->harq_ack[subframe].harq_id = harq_pid;
+
     conv_rballoc(rah,
 		 rballoc,
 		 frame_parms->N_RB_DL,
 		 dlsch0_harq->rb_alloc);
+
     dlsch1_harq->rb_alloc[0]                         = dlsch0_harq->rb_alloc[0];
 
     dlsch0_harq->nb_rb                               = conv_nprb(rah,
-										      rballoc,
-										      frame_parms->N_RB_DL);
+								 rballoc,
+								 frame_parms->N_RB_DL);
     dlsch1_harq->nb_rb                               = dlsch0_harq->nb_rb;
 
     dlsch0_harq->mcs       = mcs1;
+    dlsch1_harq->mcs       = mcs2;
 
     dlsch0_harq->delta_PUCCH     = delta_PUCCH_lut[TPC&3];      
-    /*
-      if (dlsch0_harq->mcs>20) {
-      msg("dci_tools.c: mcs > 20 disabled for now (asked %d)\n",dlsch0_harq->mcs);
-      return(-1);
-      }
-    */
+    dlsch1_harq->delta_PUCCH     = delta_PUCCH_lut[TPC&3];      
 
-    dlsch1_harq->mcs       = mcs2;
     dlsch0_harq->rvidx     = rv1;
     dlsch1_harq->rvidx     = rv2;
 
     // check if either TB is disabled (see 36-213 V8.6 p. 26)
+    if ((dlsch0_harq->rvidx == 1) && (dlsch0_harq->mcs == 0)) 
+      dlsch0->active = 0;
+    else
+      dlsch0->active = 1;
+
+    if ((dlsch1_harq->rvidx == 1) && (dlsch1_harq->mcs == 0)) 
+      dlsch1->active = 0;
+    else
+      dlsch1->active = 1;
 
-    if ((dlsch0_harq->rvidx == 1) && (dlsch0_harq->mcs == 0)) {
-      dlsch0_harq->status = DISABLED;
-    }
-    if ((dlsch1_harq->rvidx == 1) && (dlsch1_harq->mcs == 0)) {
-      dlsch1_harq->status = DISABLED;
-    }
     dlsch0_harq->Nl        = 1;
+    dlsch1_harq->Nl        = 1;
 
     //    dlsch0->layer_index                         = tbswap;
     //    dlsch1->layer_index                         = 1-tbswap;
 
-    switch (tpmi) {
-    case 0 :
-      dlsch0_harq->mimo_mode   = ALAMOUTI;
-      break;
-    case 1:
-      dlsch0_harq->mimo_mode   = UNIFORM_PRECODING11;
-      dlsch0_harq->pmi_alloc                             = pmi_extend(frame_parms,0);
-      break;
-    case 2:
-      dlsch0_harq->mimo_mode   = UNIFORM_PRECODING1m1;
-      dlsch0_harq->pmi_alloc                             = pmi_extend(frame_parms,1);
-      break;
-    case 3:
-      dlsch0_harq->mimo_mode   = UNIFORM_PRECODING1j;
-      dlsch0_harq->pmi_alloc                             = pmi_extend(frame_parms,2);
-      break;
-    case 4:
-      dlsch0_harq->mimo_mode   = UNIFORM_PRECODING1mj;
-      dlsch0_harq->pmi_alloc                             = pmi_extend(frame_parms,3);
-      break;
-    case 5:
-      dlsch0_harq->mimo_mode   = PUSCH_PRECODING0;
-      // pmi stored from ulsch allocation routine
-      dlsch0_harq->pmi_alloc                             = dlsch0->pmi_alloc;
-      //LOG_I(PHY,"XXX using PMI %x\n",pmi2hex_2Ar1(dlsch0_harq->pmi_alloc));
-      break;
-    case 6:
-      dlsch0_harq->mimo_mode   = PUSCH_PRECODING1;
-      LOG_E(PHY,"Unsupported TPMI\n");
-      return(-1);
-      break;
+    if (dlsch1->active==1) {  //two codewords
+      dlsch0_harq->dl_power_off = 1; //no power offset??
+      dlsch1_harq->dl_power_off = 1; //no power offset??
+      switch (tpmi) {
+      case 0:
+	dlsch0_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODING1;
+	dlsch1_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODING1;
+	dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,0);
+	dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,1);
+	break;
+      case 1:
+	dlsch0_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODINGj;
+	dlsch1_harq->mimo_mode   = DUALSTREAM_UNIFORM_PRECODINGj;
+	dlsch0_harq->pmi_alloc   = pmi_extend(frame_parms,2);
+	dlsch1_harq->pmi_alloc   = pmi_extend(frame_parms,3);
+	break;
+      case 2: // PUSCH precoding
+	dlsch0_harq->mimo_mode   = DUALSTREAM_PUSCH_PRECODING;
+	dlsch0_harq->pmi_alloc   = 0; //TODO: DL_pmi_single;
+	dlsch1_harq->mimo_mode   = DUALSTREAM_PUSCH_PRECODING;
+	dlsch1_harq->pmi_alloc   = 0; //TODO: DL_pmi_single;
+	break;
+      default:
+	break;
+      }
+    }
+    else {
+      dlsch0_harq->dl_power_off = 1;//????
+      switch (tpmi) {
+      case 0 :
+	dlsch0_harq->mimo_mode   = ALAMOUTI;
+	break;
+      case 1:
+	dlsch0_harq->mimo_mode   = UNIFORM_PRECODING11;
+	dlsch0_harq->pmi_alloc                             = pmi_extend(frame_parms,0);
+	break;
+      case 2:
+	dlsch0_harq->mimo_mode   = UNIFORM_PRECODING1m1;
+	dlsch0_harq->pmi_alloc                             = pmi_extend(frame_parms,1);
+	break;
+      case 3:
+	dlsch0_harq->mimo_mode   = UNIFORM_PRECODING1j;
+	dlsch0_harq->pmi_alloc                             = pmi_extend(frame_parms,2);
+	break;
+      case 4:
+	dlsch0_harq->mimo_mode   = UNIFORM_PRECODING1mj;
+	dlsch0_harq->pmi_alloc                             = pmi_extend(frame_parms,3);
+	break;
+      case 5:
+	dlsch0_harq->mimo_mode   = PUSCH_PRECODING0;
+	// pmi stored from ulsch allocation routine
+	dlsch0_harq->pmi_alloc                             = dlsch0->pmi_alloc;
+	//LOG_I(PHY,"XXX using PMI %x\n",pmi2hex_2Ar1(dlsch0_harq->pmi_alloc));
+	break;
+      case 6:
+	dlsch0_harq->mimo_mode   = PUSCH_PRECODING1;
+	LOG_E(PHY,"Unsupported TPMI\n");
+	return(-1);
+	break;
+      }
     }
-
 
     if (frame_parms->mode1_flag == 1)
       dlsch0_harq->mimo_mode   = SISO;
-    if (ndi1!=dlsch0_harq->DCINdi) {
-      dlsch0_harq->round = 0;
-      dlsch0_harq->status = ACTIVE;
-      dlsch0_harq->DCINdi         = ndi1;
-    }      
-    else if (dlsch0_harq->status == SCH_IDLE) {  // we got an Ndi = 0 for a previously decoded process,
+
+    if (dlsch0->active == 1) {
+      if ((ndi1!=dlsch0_harq->DCINdi) ||
+	  (dlsch0_harq->first_tx==1))  {
+	dlsch0_harq->round = 0;
+	dlsch0_harq->status = ACTIVE;
+	dlsch0_harq->DCINdi         = ndi1;
+	if (dlsch0_harq->first_tx==1) {
+	  LOG_D(PHY,"Format 2 DCI First TX0: Clearing flag\n");
+	  dlsch0_harq->first_tx = 0;
+	}
+      }      
+      else if (dlsch0_harq->status == SCH_IDLE) {  // we got an Ndi = 0 for a previously decoded process,
       // this happens if either another harq process in the same
       // is NAK or an ACK was not received
+	
+	dlsch0->harq_ack[subframe].ack              = 1;
+	dlsch0->harq_ack[subframe].harq_id          = harq_pid;
+	dlsch0->harq_ack[subframe].send_harq_status = 1;
+	dlsch0->active = 0;
+      }
+    }
 
-      dlsch0->harq_ack[subframe].ack              = 1;
-      dlsch0->harq_ack[subframe].harq_id          = harq_pid;
-      dlsch0->harq_ack[subframe].send_harq_status = 1;
-      dlsch0->active = 0;
-      return(0);
+    if (dlsch1->active == 1) {
+      if ((ndi2!=dlsch1_harq->DCINdi) ||
+	  (dlsch1_harq->first_tx==1)) {
+	dlsch1_harq->round = 0;
+	dlsch1_harq->status = ACTIVE;
+	dlsch1_harq->DCINdi         = ndi2;
+	if (dlsch1_harq->first_tx==1) {
+	  LOG_D(PHY,"Format 2 DCI First TX1: Clearing flag\n");
+	  dlsch1_harq->first_tx = 0;
+	}
+      }      
+      else if (dlsch1_harq->status == SCH_IDLE) {  // we got an Ndi = 0 for a previously decoded process,
+      // this happens if either another harq process in the same
+      // is NAK or an ACK was not received
+	
+	dlsch1->harq_ack[subframe].ack              = 1;
+	dlsch1->harq_ack[subframe].harq_id          = harq_pid;
+	dlsch1->harq_ack[subframe].send_harq_status = 1;
+	dlsch1->active = 0;
+      }
     }
-    dlsch0_harq->mcs         = mcs1;
+
     if (dlsch0_harq->nb_rb>1) {
       dlsch0_harq->TBS         = TBStable[get_I_TBS(dlsch0_harq->mcs)][dlsch0_harq->nb_rb-1];
     }
     else
-      dlsch0_harq->TBS         =0;
-    /*
-      if (dlsch0_harq->mcs > 18)
-      printf("mcs %d, TBS %d\n",dlsch0_harq->mcs,dlsch0_harq->TBS);
-    */
+      dlsch0_harq->TBS         = 0;
 
-    if (dlsch1_harq->DCINdi != ndi2) {
-      dlsch1_harq->round=0;
-      dlsch1_harq->status = ACTIVE;
-    }
-    dlsch1_harq->DCINdi      = ndi2;
-    dlsch1_harq->mcs         = mcs2;
     if (dlsch1_harq->nb_rb>1) {
-      dlsch1_harq->TBS       = TBStable[dlsch1_harq->mcs][dlsch1_harq->nb_rb-1];
+      dlsch1_harq->TBS         = TBStable[get_I_TBS(dlsch1_harq->mcs)][dlsch1_harq->nb_rb-1];
     }
     else
       dlsch1_harq->TBS         = 0;
@@ -4131,11 +4216,8 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
     dlsch0->rnti = rnti;
     dlsch1->rnti = rnti;
 
-    dlsch0_harq->dl_power_off = 1; //no power offset
-    dlsch1_harq->dl_power_off = 1; //no power offset
-
-    dlsch0->active = 1;
-    dlsch1->active = 1;
+   // dlsch0_harq->dl_power_off = 1; //no power offset
+   // dlsch1_harq->dl_power_off = 1; //no power offset
 
     break;
 
@@ -4461,7 +4543,7 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	dlsch0_harq->status = ACTIVE;
 	dlsch0_harq->DCINdi = ndi1;
 	if (dlsch0_harq->first_tx==1) {
-	  LOG_D(PHY,"[PDSCH %x/%d] Format 2A DCI First TX0: Clearing flag\n");
+	  LOG_D(PHY,"Format 2A DCI First TX0: Clearing flag\n");
 	  dlsch0_harq->first_tx = 0;
 	}
       }
@@ -4485,7 +4567,7 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
 	dlsch1_harq->DCINdi = ndi2;
 	
 	if (dlsch1_harq->first_tx==1) {
-	  LOG_D(PHY,"[PDSCH %x/%d] Format 2A DCI First TX1: Clearing flag\n",rnti,harq_pid);
+	  LOG_D(PHY,"Format 2A DCI First TX1: Clearing flag\n",rnti,harq_pid);
 	  dlsch1_harq->first_tx = 0;
 	}
 
@@ -4768,7 +4850,7 @@ int generate_ue_dlsch_params_from_dci(uint8_t subframe,
   dlsch[0]->active=1;
 
   // compute DL power control parameters   
-  computeRhoA_UE(pdsch_config_dedicated, dlsch[0],dlsch0_harq->dl_power_off);
+  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);
 
diff --git a/openair1/PHY/LTE_TRANSPORT/defs.h b/openair1/PHY/LTE_TRANSPORT/defs.h
index aedd996ad38..67c0112af22 100644
--- a/openair1/PHY/LTE_TRANSPORT/defs.h
+++ b/openair1/PHY/LTE_TRANSPORT/defs.h
@@ -695,6 +695,12 @@ typedef enum {
   PMCH
 } PDSCH_t;
 
+typedef enum {
+  rx_standard=0,
+  rx_IC_single_stream,
+  rx_IC_dual_stream,
+} RX_type_t;
+
 typedef enum {
   pucch_format1=0,
   pucch_format1a,
diff --git a/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c b/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c
index 6428a3899fb..9655716b90a 100644
--- a/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c
+++ b/openair1/PHY/LTE_TRANSPORT/dlsch_demodulation.c
@@ -84,7 +84,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
              uint8_t subframe,
              unsigned char symbol,
              unsigned char first_symbol_flag,
-             unsigned char dual_stream_flag,
+             RX_type_t rx_type,
              unsigned char i_mod,
              unsigned char harq_pid) {
   
@@ -95,10 +95,13 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
   LTE_UE_DLSCH_t   **dlsch_ue;
 
   unsigned char aatx,aarx;    
-  unsigned short nb_rb;
+  unsigned short nb_rb, round;
   int avgs, rb;  
   LTE_DL_UE_HARQ_t *dlsch0_harq,*dlsch1_harq = 0;
 
+  int32_t **rxdataF_comp_ptr;
+  int32_t **dl_ch_mag_ptr;
+
   switch (type) {
   case SI_PDSCH:
     lte_ue_pdsch_vars = &phy_vars_ue->lte_ue_pdsch_vars_SI[eNB_id];
@@ -123,6 +126,8 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     break;
   }
 
+  DevAssert(dlsch0_harq);
+  round = dlsch0_harq->round;
 
   if (eNB_id > 2) {
     LOG_W(PHY,"dlsch_demodulation.c: Illegal eNB_id %d\n",eNB_id);
@@ -148,7 +153,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     LOG_W(PHY,"dlsch_demodulation.c: Null lte_frame_parms\n");
     return(-1);
   }
-  //  printf("rx_dlsch subframe %d symbol %d: eNB_id %d, eNB_id_i %d, dual_stream_flag %d\n",subframe,symbol,eNB_id,eNB_id_i,dual_stream_flag); 
+  //printf("rx_dlsch subframe %d symbol %d: eNB_id %d, eNB_id_i %d\n",subframe,symbol,eNB_id,eNB_id_i); 
   //  symbol_mod = (symbol>=(7-frame_parms->Ncp)) ? symbol-(7-frame_parms->Ncp) : symbol;
 
   /*
@@ -158,87 +163,101 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     pilots=0;
   */
 
+  if (dlsch0_harq->mimo_mode>DUALSTREAM_UNIFORM_PRECODINGj) {
+    LOG_E(PHY,"This transmission mode is not yet supported!\n");
+    return(-1);
+  }
+  if ((dlsch0_harq->mimo_mode==LARGE_CDD) || ((dlsch0_harq->mimo_mode>=DUALSTREAM_UNIFORM_PRECODING1) && (dlsch0_harq->mimo_mode<=DUALSTREAM_PUSCH_PRECODING)))  {
+    DevAssert(dlsch1_harq);
+    if (eNB_id!=eNB_id_i) {
+      LOG_E(PHY,"TM3/TM4 requires to set eNB_id==eNB_id_i!\n");
+      return(-1);
+    }
+  }
+
+  //printf("rx_pdsch: harq_pid=%d, round=%d\n",harq_pid,round);
+
   if (frame_parms->nb_antennas_tx_eNB>1) {
 #ifdef DEBUG_DLSCH_MOD     
     LOG_I(PHY,"dlsch: using pmi %x (%p), rb_alloc %x\n",pmi2hex_2Ar1(dlsch0_harq->pmi_alloc),dlsch_ue[0],dlsch0_harq->rb_alloc[0]);
 #endif
     nb_rb = dlsch_extract_rbs_dual(lte_ue_common_vars->rxdataF,
-				   lte_ue_common_vars->dl_ch_estimates[eNB_id],
-				   lte_ue_pdsch_vars[eNB_id]->rxdataF_ext,
-				   lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-				   dlsch0_harq->pmi_alloc,
-				   lte_ue_pdsch_vars[eNB_id]->pmi_ext,
-				   dlsch0_harq->rb_alloc,
-				   symbol,
-				   subframe,
-				   phy_vars_ue->high_speed_flag,
-				   frame_parms);
-
-    if (dual_stream_flag==1) {
-      if (eNB_id_i<phy_vars_ue->n_connected_eNB)
-	nb_rb = dlsch_extract_rbs_dual(lte_ue_common_vars->rxdataF,
-				       lte_ue_common_vars->dl_ch_estimates[eNB_id_i],
-				       lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext,
-				       lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
-				       dlsch0_harq->pmi_alloc,
-				       lte_ue_pdsch_vars[eNB_id_i]->pmi_ext,
-				       dlsch0_harq->rb_alloc,
-				       symbol,
-				       subframe,
-				       phy_vars_ue->high_speed_flag,
-				       frame_parms);
+                                   lte_ue_common_vars->dl_ch_estimates[eNB_id],
+                                   lte_ue_pdsch_vars[eNB_id]->rxdataF_ext,
+                                   lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+                                   dlsch0_harq->pmi_alloc,
+                                   lte_ue_pdsch_vars[eNB_id]->pmi_ext,
+                                   dlsch0_harq->rb_alloc,
+                                   symbol,
+                                   subframe,
+                                   phy_vars_ue->high_speed_flag,
+                                   frame_parms);
+
+    if (rx_type==rx_IC_single_stream) {
+      if (eNB_id_i<phy_vars_ue->n_connected_eNB) // we are in TM5
+        nb_rb = dlsch_extract_rbs_dual(lte_ue_common_vars->rxdataF,
+                                       lte_ue_common_vars->dl_ch_estimates[eNB_id_i],
+                                       lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext,
+                                       lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
+                                       dlsch0_harq->pmi_alloc,
+                                       lte_ue_pdsch_vars[eNB_id_i]->pmi_ext,
+                                       dlsch0_harq->rb_alloc,
+                                       symbol,
+                                       subframe,
+                                       phy_vars_ue->high_speed_flag,
+                                       frame_parms);
       else 
-	nb_rb = dlsch_extract_rbs_dual(lte_ue_common_vars->rxdataF,
-				       lte_ue_common_vars->dl_ch_estimates[eNB_id],
-				       lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext,
-				       lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
-				       dlsch0_harq->pmi_alloc,
-				       lte_ue_pdsch_vars[eNB_id_i]->pmi_ext,
-				       dlsch0_harq->rb_alloc,
-				       symbol,
-				       subframe,
-				       phy_vars_ue->high_speed_flag,
-				       frame_parms);
+        nb_rb = dlsch_extract_rbs_dual(lte_ue_common_vars->rxdataF,
+                                       lte_ue_common_vars->dl_ch_estimates[eNB_id],
+                                       lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext,
+                                       lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
+                                       dlsch0_harq->pmi_alloc,
+                                       lte_ue_pdsch_vars[eNB_id_i]->pmi_ext,
+                                       dlsch0_harq->rb_alloc,
+                                       symbol,
+                                       subframe,
+                                       phy_vars_ue->high_speed_flag,
+                                       frame_parms);
     }
   } // if n_tx>1
   else {     
     nb_rb = dlsch_extract_rbs_single(lte_ue_common_vars->rxdataF,
-				     lte_ue_common_vars->dl_ch_estimates[eNB_id],
-				     lte_ue_pdsch_vars[eNB_id]->rxdataF_ext,
-				     lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-				     dlsch0_harq->pmi_alloc,
-				     lte_ue_pdsch_vars[eNB_id]->pmi_ext,
-				     dlsch0_harq->rb_alloc,
-				     symbol,
-				     subframe,
-				     phy_vars_ue->high_speed_flag,
-				     frame_parms);
+                                     lte_ue_common_vars->dl_ch_estimates[eNB_id],
+                                     lte_ue_pdsch_vars[eNB_id]->rxdataF_ext,
+                                     lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+                                     dlsch0_harq->pmi_alloc,
+                                     lte_ue_pdsch_vars[eNB_id]->pmi_ext,
+                                     dlsch0_harq->rb_alloc,
+                                     symbol,
+                                     subframe,
+                                     phy_vars_ue->high_speed_flag,
+                                     frame_parms);
         
-    if (dual_stream_flag==1) {
+    if (rx_type==rx_IC_single_stream) {
       if (eNB_id_i<phy_vars_ue->n_connected_eNB)
-	nb_rb = dlsch_extract_rbs_single(lte_ue_common_vars->rxdataF,
-					 lte_ue_common_vars->dl_ch_estimates[eNB_id_i],
-					 lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext,
-					 lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,    
-					 dlsch0_harq->pmi_alloc,
-					 lte_ue_pdsch_vars[eNB_id_i]->pmi_ext,
-					 dlsch0_harq->rb_alloc,
-					 symbol,
-					 subframe,
-					 phy_vars_ue->high_speed_flag,
-					 frame_parms);
+        nb_rb = dlsch_extract_rbs_single(lte_ue_common_vars->rxdataF,
+                                         lte_ue_common_vars->dl_ch_estimates[eNB_id_i],
+                                         lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext,
+                                         lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,    
+                                         dlsch0_harq->pmi_alloc,
+                                         lte_ue_pdsch_vars[eNB_id_i]->pmi_ext,
+                                         dlsch0_harq->rb_alloc,
+                                         symbol,
+                                         subframe,
+                                         phy_vars_ue->high_speed_flag,
+                                         frame_parms);
       else 
-	nb_rb = dlsch_extract_rbs_single(lte_ue_common_vars->rxdataF,
-					 lte_ue_common_vars->dl_ch_estimates[eNB_id],
-					 lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext,
-					 lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,    
-					 dlsch0_harq->pmi_alloc,
-					 lte_ue_pdsch_vars[eNB_id_i]->pmi_ext,
-					 dlsch0_harq->rb_alloc,
-					 symbol,
-					 subframe,
-					 phy_vars_ue->high_speed_flag,
-					 frame_parms);
+        nb_rb = dlsch_extract_rbs_single(lte_ue_common_vars->rxdataF,
+                                         lte_ue_common_vars->dl_ch_estimates[eNB_id],
+                                         lte_ue_pdsch_vars[eNB_id_i]->rxdataF_ext,
+                                         lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,    
+                                         dlsch0_harq->pmi_alloc,
+                                         lte_ue_pdsch_vars[eNB_id_i]->pmi_ext,
+                                         dlsch0_harq->rb_alloc,
+                                         symbol,
+                                         subframe,
+                                         phy_vars_ue->high_speed_flag,
+                                         frame_parms);
     }
   } //else n_tx>1
   
@@ -257,10 +276,10 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
   */
   if (first_symbol_flag==1) {
     dlsch_channel_level(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-			frame_parms,
-			avg,
-			symbol,
-			nb_rb);
+                        frame_parms,
+                        avg,
+                        symbol,
+                        nb_rb);
 #ifdef DEBUG_PHY
     LOG_D(PHY,"[DLSCH] avg[0] %d\n",avg[0]);
 #endif
@@ -271,8 +290,8 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     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]);
+        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);
@@ -280,10 +299,12 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     //      + log2_approx(frame_parms->nb_antennas_rx-1);
 
     if ((dlsch0_harq->mimo_mode>=UNIFORM_PRECODING11) &&
-	(dlsch0_harq->mimo_mode< DUALSTREAM_UNIFORM_PRECODING1) &&
-	(dlsch0_harq->dl_power_off==1)) // we are in TM 6
+        (dlsch0_harq->mimo_mode< DUALSTREAM_UNIFORM_PRECODING1) &&
+        (dlsch0_harq->dl_power_off==1)) // we are in TM 6
       lte_ue_pdsch_vars[eNB_id]->log2_maxh++;
 
+    //printf("log2_maxh =%d\n",lte_ue_pdsch_vars[eNB_id]->log2_maxh);
+    
     // this version here applies the factor .5 also to the extra terms. however, it does not work so well as the one above
     /* K = Nb_rx         in TM1 
        Nb_tx*Nb_rx   in TM2,4,5
@@ -307,249 +328,297 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
   aarx = frame_parms->nb_antennas_rx;
 
   if (dlsch0_harq->mimo_mode<LARGE_CDD) {// SISO or ALAMOUTI
-
+    
     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,
-			       lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			       (aatx>1) ? lte_ue_pdsch_vars[eNB_id]->rho : NULL,
-			       frame_parms,
-			       symbol,
-			       first_symbol_flag,
-			       get_Qm(dlsch0_harq->mcs),
-			       nb_rb,
-			       lte_ue_pdsch_vars[eNB_id]->log2_maxh,
-			       phy_measurements); // log2_maxh+I0_shift
-#ifdef DEBUG_PHY
-    if (symbol==5)
-      write_output("rxF_comp_d.m","rxF_c_d",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
-#endif
-      
-    if ((dual_stream_flag==1) && 
-	(eNB_id_i<phy_vars_ue->n_connected_eNB)) {
+                               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,
+                               lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                               (aatx>1) ? lte_ue_pdsch_vars[eNB_id]->rho : NULL,
+                               frame_parms,
+                               symbol,
+                               first_symbol_flag,
+                               get_Qm(dlsch0_harq->mcs),
+                               nb_rb,
+                               lte_ue_pdsch_vars[eNB_id]->log2_maxh,
+                               phy_measurements); // log2_maxh+I0_shift
+ /*
+ if (symbol == 5) {
+     write_output("rxF_comp_d.m","rxF_c_d",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
+ } */
+    if ((rx_type==rx_IC_single_stream) && 
+        (eNB_id_i<phy_vars_ue->n_connected_eNB)) {
+      // we don't use IA receiver for TM1 and TM2
       // get MF output for interfering stream
       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,
-				 lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0,
-				 (aatx>1) ? lte_ue_pdsch_vars[eNB_id_i]->rho : NULL,
-				 frame_parms,
-				 symbol,
-				 first_symbol_flag,
-				 i_mod,
-				 nb_rb,
-				 lte_ue_pdsch_vars[eNB_id]->log2_maxh,
-				 phy_measurements); // log2_maxh+I0_shift
+                                 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,
+                                 lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0,
+                                 (aatx>1) ? lte_ue_pdsch_vars[eNB_id_i]->rho : NULL,
+                                 frame_parms,
+                                 symbol,
+                                 first_symbol_flag,
+                                 i_mod,
+                                 nb_rb,
+                                 lte_ue_pdsch_vars[eNB_id]->log2_maxh,
+                                 phy_measurements); // log2_maxh+I0_shift
 #ifdef DEBUG_PHY
       if (symbol == 5) {
-	write_output("rxF_comp_d.m","rxF_c_d",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
-	write_output("rxF_comp_i.m","rxF_c_i",&lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);     
+        write_output("rxF_comp_d.m","rxF_c_d",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
+        write_output("rxF_comp_i.m","rxF_c_i",&lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);     
       }
 #endif 
-	
+        
       // compute correlation between signal and interference channels
       dlsch_dual_stream_correlation(frame_parms,
-				    symbol,
-				    nb_rb,
-				    lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-				    lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
-				    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext,
-				    lte_ue_pdsch_vars[eNB_id]->log2_maxh);
+                                    symbol,
+                                    nb_rb,
+                                    lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+                                    lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
+                                    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
+                                    lte_ue_pdsch_vars[eNB_id]->log2_maxh);
     }
+    
   }
-  else if (dlsch0_harq->mimo_mode == LARGE_CDD) {  // TM3
+  else if ((dlsch0_harq->mimo_mode == LARGE_CDD) || 
+           ((dlsch0_harq->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) && 
+            (dlsch0_harq->mimo_mode <=DUALSTREAM_PUSCH_PRECODING))){  // TM3 or TM4
     //   LOG_I(PHY,"Running PDSCH RX for TM3\n");
+	      
     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);
+	
+	        
       if (first_symbol_flag==1) {
-	// effective channel of desired user is always stronger than interfering eff. channel
-	dlsch_channel_level_TM3(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, 
-				frame_parms, 
-				avg, symbol, nb_rb);
+        // effective channel of desired user is always stronger than interfering eff. channel
 	
-	//	LOG_D(PHY,"llr_offset = %d\n",offset_mumimo_llr_drange[dlsch0_harq->mcs][(dlsch1_harq->mcs>>1)-1]);
-	avg[0] = log2_approx(avg[0]) - 13 + offset_mumimo_llr_drange[dlsch0_harq->mcs][(get_Qm(dlsch1_harq->mcs)>>1)-1];
-
-	lte_ue_pdsch_vars[eNB_id]->log2_maxh = cmax(avg[0],0);
-	//	printf("log2_maxh =%d\n",lte_ue_pdsch_vars[eNB_id]->log2_maxh);
-      }    
-      dlsch_channel_compensation_TM3(frame_parms, 
-				     lte_ue_pdsch_vars[eNB_id],
-				     phy_measurements, 
-				     eNB_id, 
-				     symbol, 
-				     get_Qm(dlsch0_harq->mcs), 
-				     get_Qm(dlsch1_harq->mcs),
-				     dlsch0_harq->round,
-				     nb_rb, 
-				     lte_ue_pdsch_vars[eNB_id]->log2_maxh); 
+        dlsch_channel_level_TM34(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, 
+                                 frame_parms, 
+                                 avg, symbol, nb_rb,
+                                 dlsch0_harq->mimo_mode);
+	    
+	/*
+	if (rx_type>rx_standard) {
+	  //	LOG_D(PHY,"llr_offset = %d\n",offset_mumimo_llr_drange[dlsch0_harq->mcs][(dlsch1_harq->mcs>>1)-1]);
+	  lte_ue_pdsch_vars[eNB_id]->log2_maxh = log2_approx(avg[0]) - 13 + offset_mumimo_llr_drange[dlsch0_harq->mcs][(get_Qm(dlsch1_harq->mcs)>>1)-1];
+	}
+	else 
+	*/
+
+	lte_ue_pdsch_vars[eNB_id]->log2_maxh = log2_approx(avg[0])/2;
+      }
+    
+      dlsch_channel_compensation_TM34(frame_parms, 
+                                     lte_ue_pdsch_vars[eNB_id],
+                                     phy_measurements, 
+                                     eNB_id, 
+                                     symbol, 
+                                     get_Qm(dlsch0_harq->mcs), 
+                                     get_Qm(dlsch1_harq->mcs),
+                                     harq_pid,
+                                     dlsch0_harq->round,
+                                     dlsch0_harq->mimo_mode,
+                                     nb_rb, 
+                                     lte_ue_pdsch_vars[eNB_id]->log2_maxh); 
+   /*   
+       if (symbol == 5) {
+   
+     write_output("rxF_comp_d00.m","rxF_c_d00",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);// should be QAM
+     write_output("rxF_comp_d01.m","rxF_c_d01",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0[1][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be almost 0
+     write_output("rxF_comp_d10.m","rxF_c_d10",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[harq_pid][round][0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);//should be almost 0
+     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,
-				    symbol,
-				    nb_rb,
-				    lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
-				    &(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext[2]),
-				    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext,
+                                    symbol,
+                                    nb_rb,
+                                    lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext,
+                                    &(lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext[2]),
+                                    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
+                                    //lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
 				    lte_ue_pdsch_vars[eNB_id]->log2_maxh);
+
+      //to be optimized (just take complex conjugate)
       dlsch_dual_stream_correlation(frame_parms,
-				    symbol,
-				    nb_rb,
-				    &(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_rho2_ext,
-				    lte_ue_pdsch_vars[eNB_id]->log2_maxh);
+                                    symbol,
+                                    nb_rb,
+                                    &(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_rho2_ext,
+				   //lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
+                                    lte_ue_pdsch_vars[eNB_id]->log2_maxh);
       //printf("TM3 log2_maxh : %d\n",lte_ue_pdsch_vars[eNB_id]->log2_maxh);
 
-    }
-    else {
+   
+}
+      else {
       LOG_E(PHY, "only 2 tx antennas supported for TM3\n");
+      return(-1);
     }
   }
-  else if (dlsch0_harq->mimo_mode<DUALSTREAM_UNIFORM_PRECODING1) {// single-layer precoding (TM5, TM6), potentially TM4 (Single-codeword)
+  else if (dlsch0_harq->mimo_mode<DUALSTREAM_UNIFORM_PRECODING1) {// single-layer precoding (TM5, TM6)
     //    printf("Channel compensation for precoding\n");
-    //    if ((dual_stream_flag==1) && (eNB_id_i==NUMBER_OF_CONNECTED_eNB_MAX)) {
-    if ((dual_stream_flag==1) && (eNB_id_i==phy_vars_ue->n_connected_eNB)) {  // TM5 two-user
+    if ((rx_type==rx_IC_single_stream) && (eNB_id_i==phy_vars_ue->n_connected_eNB)) {  // TM5 two-user
 
       // Scale the channel estimates for interfering stream
 
       dlsch_scale_channel(lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext,
-			  frame_parms,
-			  dlsch_ue,
-			  symbol,
-			  nb_rb);     
+                          frame_parms,
+                          dlsch_ue,
+                          symbol,
+                          nb_rb);     
 
       /* compute new log2_maxh for effective channel */
       if (first_symbol_flag==1) {
-	// 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);
-	
-	//    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];
+        // 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);
+        
+        //    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];
 
-	lte_ue_pdsch_vars[eNB_id]->log2_maxh = cmax(avg[0],0);
-	//printf("log1_maxh =%d\n",lte_ue_pdsch_vars[eNB_id]->log2_maxh);
+        lte_ue_pdsch_vars[eNB_id]->log2_maxh = cmax(avg[0],0);
+        //printf("log1_maxh =%d\n",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, 
-				      lte_ue_pdsch_vars[eNB_id]->dl_ch_magb0, 
-				      lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, 
-				      lte_ue_pdsch_vars[eNB_id]->pmi_ext, 
-				      frame_parms, 
-				      phy_measurements, 
-				      eNB_id, 
-				      symbol, 
-				      get_Qm(dlsch0_harq->mcs), 
-				      nb_rb, 
-				      lte_ue_pdsch_vars[eNB_id]->log2_maxh, 
-				      dlsch0_harq->dl_power_off);
+                                      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, 
+                                      lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0, 
+                                      lte_ue_pdsch_vars[eNB_id]->pmi_ext, 
+                                      frame_parms, 
+                                      phy_measurements, 
+                                      eNB_id, 
+                                      symbol, 
+                                      get_Qm(dlsch0_harq->mcs), 
+                                      nb_rb, 
+                                      lte_ue_pdsch_vars[eNB_id]->log2_maxh, 
+                                      dlsch0_harq->dl_power_off);
 
       // if interference source is MU interference, assume opposite precoder was used at eNB
 
       // calculate opposite PMI
       for (rb=0;rb<nb_rb;rb++) {
-	switch(lte_ue_pdsch_vars[eNB_id]->pmi_ext[rb]) {
-	case 0:
-	  lte_ue_pdsch_vars[eNB_id_i]->pmi_ext[rb]=1;
-	  break;
-	case 1:
-	  lte_ue_pdsch_vars[eNB_id_i]->pmi_ext[rb]=0;
-	  break;
-	case 2:
-	  lte_ue_pdsch_vars[eNB_id_i]->pmi_ext[rb]=3;
-	  break;
-	case 3:
-	  lte_ue_pdsch_vars[eNB_id_i]->pmi_ext[rb]=2;
-	  break;
-	}
-	//	if (rb==0)
-	//	  printf("pmi %d, pmi_i %d\n",lte_ue_pdsch_vars[eNB_id]->pmi_ext[rb],lte_ue_pdsch_vars[eNB_id_i]->pmi_ext[rb]);
-	
+        switch(lte_ue_pdsch_vars[eNB_id]->pmi_ext[rb]) {
+        case 0:
+          lte_ue_pdsch_vars[eNB_id_i]->pmi_ext[rb]=1;
+          break;
+        case 1:
+          lte_ue_pdsch_vars[eNB_id_i]->pmi_ext[rb]=0;
+          break;
+        case 2:
+          lte_ue_pdsch_vars[eNB_id_i]->pmi_ext[rb]=3;
+          break;
+        case 3:
+          lte_ue_pdsch_vars[eNB_id_i]->pmi_ext[rb]=2;
+          break;
+        }
+        //      if (rb==0)
+        //        printf("pmi %d, pmi_i %d\n",lte_ue_pdsch_vars[eNB_id]->pmi_ext[rb],lte_ue_pdsch_vars[eNB_id_i]->pmi_ext[rb]);
+        
       }
 
       dlsch_channel_compensation_TM56(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, 
-				      lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0, 
-				      lte_ue_pdsch_vars[eNB_id_i]->pmi_ext, 
-				      frame_parms, 
-				      phy_measurements, 
-				      eNB_id_i, 
-				      symbol, 
-				      i_mod, 
-				      nb_rb, 
-				      lte_ue_pdsch_vars[eNB_id]->log2_maxh, 
-				      dlsch0_harq->dl_power_off);
+                                      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, 
+                                      lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0, 
+                                      lte_ue_pdsch_vars[eNB_id_i]->pmi_ext, 
+                                      frame_parms, 
+                                      phy_measurements, 
+                                      eNB_id_i, 
+                                      symbol, 
+                                      i_mod, 
+                                      nb_rb, 
+                                      lte_ue_pdsch_vars[eNB_id]->log2_maxh, 
+                                      dlsch0_harq->dl_power_off);
         
 #ifdef DEBUG_PHY
       if (symbol==5) {
-	write_output("rxF_comp_d.m","rxF_c_d",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
-	write_output("rxF_comp_i.m","rxF_c_i",&lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);    
+        write_output("rxF_comp_d.m","rxF_c_d",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
+        write_output("rxF_comp_i.m","rxF_c_i",&lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);    
       }
 #endif  
 
       dlsch_dual_stream_correlation(frame_parms, 
-				    symbol, 
-				    nb_rb, 
-				    lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, 
-				    lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext, 
-				    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext, 
-				    lte_ue_pdsch_vars[eNB_id]->log2_maxh);
+                                    symbol, 
+                                    nb_rb, 
+                                    lte_ue_pdsch_vars[eNB_id]->dl_ch_estimates_ext, 
+                                    lte_ue_pdsch_vars[eNB_id_i]->dl_ch_estimates_ext, 
+                                    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round], 
+                                    lte_ue_pdsch_vars[eNB_id]->log2_maxh);
 
     }
     else {
       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,
-				      lte_ue_pdsch_vars[eNB_id]->dl_ch_magb0,
-				      lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-				      lte_ue_pdsch_vars[eNB_id]->pmi_ext,
-				      frame_parms,
-				      phy_measurements,
-				      eNB_id,
-				      symbol,
-				      get_Qm(dlsch0_harq->mcs),
-				      nb_rb,
-				      lte_ue_pdsch_vars[eNB_id]->log2_maxh,
-				      1);
+                                      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,
+                                      lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                                      lte_ue_pdsch_vars[eNB_id]->pmi_ext,
+                                      frame_parms,
+                                      phy_measurements,
+                                      eNB_id,
+                                      symbol,
+                                      get_Qm(dlsch0_harq->mcs),
+                                      nb_rb,
+                                      lte_ue_pdsch_vars[eNB_id]->log2_maxh,
+                                      1);
+      //write_output("rxF_comp_d.m","rxF_c_d",&lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0[0][symbol*frame_parms->N_RB_DL*12],frame_parms->N_RB_DL*12,1,1);
     }
   }
 
   //  printf("MRC\n");
   if (frame_parms->nb_antennas_rx > 1) {
-    if (dlsch0_harq->mimo_mode == LARGE_CDD) {
+    if ((dlsch0_harq->mimo_mode == LARGE_CDD) ||
+        ((dlsch0_harq->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) && 
+         (dlsch0_harq->mimo_mode <=DUALSTREAM_PUSCH_PRECODING))){  // TM3 or TM4
       if (frame_parms->nb_antennas_tx_eNB == 2) {
-	dlsch_detection_mrc(frame_parms,
-			    lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			    lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[dlsch0_harq->round],
-			    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext,
-			    lte_ue_pdsch_vars[eNB_id]->rho,
-			    lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-			    lte_ue_pdsch_vars[eNB_id]->dl_ch_magb0,
-			    lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1,
-			    lte_ue_pdsch_vars[eNB_id]->dl_ch_magb1,
-			    symbol,
-			    nb_rb,
-			    dual_stream_flag); 			    
+	dlsch_detection_mrc_TM34(frame_parms, 
+                                 lte_ue_pdsch_vars[eNB_id],
+				 harq_pid,
+                                 dlsch0_harq->round,
+				 symbol,
+				 nb_rb,
+				 1);
+        /*dlsch_detection_mrc(frame_parms,
+                            lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                            lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[harq_pid][round],
+                            lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
+                            lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
+                            lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
+                            lte_ue_pdsch_vars[eNB_id]->dl_ch_magb0,
+                            lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1,
+                            lte_ue_pdsch_vars[eNB_id]->dl_ch_magb1,
+                            symbol,
+                            nb_rb,
+                            1); //dual_stream_flag);*/ //this has to be 1, otherwise mrc is not done on second stream
       }
     }
     else {
       
       dlsch_detection_mrc(frame_parms,
-			  lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			  lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0,
-			  lte_ue_pdsch_vars[eNB_id]->rho,
-			  lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext,
-			  lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-			  lte_ue_pdsch_vars[eNB_id]->dl_ch_magb0,
-			  lte_ue_pdsch_vars[eNB_id_i]->dl_ch_mag0,
-			  lte_ue_pdsch_vars[eNB_id_i]->dl_ch_magb0,
-			  symbol,
-			  nb_rb,
-			  dual_stream_flag); 
+                          lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                          lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0,
+                          lte_ue_pdsch_vars[eNB_id]->rho,
+                          lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
+                          lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
+                          lte_ue_pdsch_vars[eNB_id]->dl_ch_magb0,
+                          lte_ue_pdsch_vars[eNB_id_i]->dl_ch_mag0,
+                          lte_ue_pdsch_vars[eNB_id_i]->dl_ch_magb0,
+                          symbol,
+                          nb_rb,
+                          rx_type==rx_IC_single_stream); 
     }
   }
   //  printf("Combining");
@@ -567,211 +636,310 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
   } else if (dlsch0_harq->mimo_mode == ALAMOUTI) {
 
     dlsch_alamouti(frame_parms,
-		   lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-		   lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-		   lte_ue_pdsch_vars[eNB_id]->dl_ch_magb0,
-		   symbol,
-		   nb_rb);
+                   lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                   lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
+                   lte_ue_pdsch_vars[eNB_id]->dl_ch_magb0,
+                   symbol,
+                   nb_rb);
           
   } 
           
-  else if (dlsch0_harq->mimo_mode == LARGE_CDD) {
-	
+  //    printf("LLR");
+  if ((dlsch0_harq->mimo_mode == LARGE_CDD) || 
+      ((dlsch0_harq->mimo_mode >=DUALSTREAM_UNIFORM_PRECODING1) && 
+       (dlsch0_harq->mimo_mode <=DUALSTREAM_PUSCH_PRECODING)))  {
+    rxdataF_comp_ptr = lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[harq_pid][round];
+    dl_ch_mag_ptr = lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1;
+    i_mod  =   get_Qm(dlsch1_harq->mcs) ;
   }
   else {
-    LOG_W(PHY,"dlsch_rx: Unknown MIMO mode\n");
-    return (-1);
+    rxdataF_comp_ptr = lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0;
+    dl_ch_mag_ptr = lte_ue_pdsch_vars[eNB_id_i]->dl_ch_mag0;
+    //i_mod should have been passed as a parameter
   }
 
-  //    printf("LLR");
-
   switch (get_Qm(dlsch0_harq->mcs)) {
   case 2 : 
-    if (dlsch0_harq->mimo_mode != LARGE_CDD) { 
-      if (dual_stream_flag == 0)
-	dlsch_qpsk_llr(frame_parms,
-		       lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-		       lte_ue_pdsch_vars[eNB_id]->llr[0],
-		       symbol,first_symbol_flag,nb_rb,
-		       adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
-		       lte_ue_pdsch_vars[eNB_id]->llr128);
-      else if (i_mod == 2) {
-	dlsch_qpsk_qpsk_llr(frame_parms,
-			    lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			    lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0,
-			    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext,
-			    lte_ue_pdsch_vars[eNB_id]->llr[0],
-			    symbol,first_symbol_flag,nb_rb,
-			    adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
-			    lte_ue_pdsch_vars[eNB_id]->llr128);
-      }
-      else if (i_mod == 4) { 
-	dlsch_qpsk_16qam_llr(frame_parms,
-			     lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			     lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0,
-			     lte_ue_pdsch_vars[eNB_id_i]->dl_ch_mag0,
-			     lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext,
-			     lte_ue_pdsch_vars[eNB_id]->llr[0],
-			     symbol,first_symbol_flag,nb_rb,
-			     adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
-			     lte_ue_pdsch_vars[eNB_id]->llr128);
+    if (rx_type==rx_standard) {
+        dlsch_qpsk_llr(frame_parms,
+                       lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                       lte_ue_pdsch_vars[eNB_id]->llr[0],
+                       symbol,first_symbol_flag,nb_rb,
+                       adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
+                       lte_ue_pdsch_vars[eNB_id]->llr128);
+    }
+      else if ((rx_type==rx_IC_single_stream) || (rx_type==rx_IC_dual_stream)) {
+        if (i_mod == 2) {
+          dlsch_qpsk_qpsk_llr(frame_parms,
+                              lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                              rxdataF_comp_ptr,
+                              lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
+                              lte_ue_pdsch_vars[eNB_id]->llr[0],
+                              symbol,first_symbol_flag,nb_rb,
+                              adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
+                              lte_ue_pdsch_vars[eNB_id]->llr128);
+          if (rx_type==rx_IC_dual_stream) {
+            dlsch_qpsk_qpsk_llr(frame_parms,
+                                rxdataF_comp_ptr,
+                                lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                                lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
+                                lte_ue_pdsch_vars[eNB_id]->llr[1],
+                                symbol,first_symbol_flag,nb_rb,
+                                adjust_G2(frame_parms,dlsch1_harq->rb_alloc,2,subframe,symbol),
+                                lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
+          }
+        }
+        else if (i_mod == 4) { 
+          dlsch_qpsk_16qam_llr(frame_parms,
+                               lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                               rxdataF_comp_ptr,//i
+                               dl_ch_mag_ptr,//i
+                               lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
+                               lte_ue_pdsch_vars[eNB_id]->llr[0],
+                               symbol,first_symbol_flag,nb_rb,
+                               adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
+                               lte_ue_pdsch_vars[eNB_id]->llr128);
+          if (rx_type==rx_IC_dual_stream) {
+            dlsch_16qam_qpsk_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_rho2_ext,
+                                 lte_ue_pdsch_vars[eNB_id]->llr[1],
+                                 symbol,first_symbol_flag,nb_rb,
+                                 adjust_G2(frame_parms,dlsch1_harq->rb_alloc,4,subframe,symbol),
+                                 lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
+          }
+        }
+        else {
+          dlsch_qpsk_64qam_llr(frame_parms,
+                               lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                               rxdataF_comp_ptr,//i
+                               dl_ch_mag_ptr,//i
+                               lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[harq_pid][round],
+                               lte_ue_pdsch_vars[eNB_id]->llr[0],
+                               symbol,first_symbol_flag,nb_rb,
+                               adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
+                               lte_ue_pdsch_vars[eNB_id]->llr128);
+          if (rx_type==rx_IC_dual_stream) {
+            dlsch_64qam_qpsk_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_rho2_ext,
+                                 lte_ue_pdsch_vars[eNB_id]->llr[1],
+                                 symbol,first_symbol_flag,nb_rb,
+                                 adjust_G2(frame_parms,dlsch1_harq->rb_alloc,6,subframe,symbol),
+                                 lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
+          }
+        }          
       }
-      else {
-	dlsch_qpsk_64qam_llr(frame_parms,
-			     lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			     lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0,
-			     lte_ue_pdsch_vars[eNB_id_i]->dl_ch_mag0,
-			     lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext,
-			     lte_ue_pdsch_vars[eNB_id]->llr[0],
-			     symbol,first_symbol_flag,nb_rb,
-			     adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
-			     lte_ue_pdsch_vars[eNB_id]->llr128);
-	    
-      }          
+    break;
+  case 4 :
+    if (rx_type==rx_standard) {
+      dlsch_16qam_llr(frame_parms,
+                      lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                      lte_ue_pdsch_vars[eNB_id]->llr[0],
+                      lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
+                      symbol,first_symbol_flag,nb_rb,
+                      adjust_G2(frame_parms,dlsch0_harq->rb_alloc,4,subframe,symbol),
+                      lte_ue_pdsch_vars[eNB_id]->llr128);
     }
-    else { // TM3
-      DevAssert(dlsch1_harq);
-      if (get_Qm(dlsch1_harq->mcs) == 2) {
-	/*	dlsch_qpsk_llr(frame_parms,
-		       lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-		       lte_ue_pdsch_vars[eNB_id]->llr[0],
-		       symbol,first_symbol_flag,nb_rb,
-		       adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
-		       lte_ue_pdsch_vars[eNB_id]->llr128);
-	*/
-	dlsch_qpsk_qpsk_llr(frame_parms,
-			    lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			    lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[dlsch0_harq->round],
-			    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext,
-			    lte_ue_pdsch_vars[eNB_id]->llr[0],
-			    symbol,first_symbol_flag,nb_rb,
-			    adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
-			    lte_ue_pdsch_vars[eNB_id]->llr128);
-	dlsch_qpsk_qpsk_llr(frame_parms,
-			    lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[dlsch0_harq->round],
-			    lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
-			    lte_ue_pdsch_vars[eNB_id]->llr[1],
-			    symbol,first_symbol_flag,nb_rb,
-			    adjust_G2(frame_parms,dlsch1_harq->rb_alloc,2,subframe,symbol),
-			    lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
+    else if ((rx_type==rx_IC_single_stream) || (rx_type==rx_IC_dual_stream)) {
+      if (i_mod == 2) {
+        dlsch_16qam_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_rho_ext[harq_pid][round],
+                             lte_ue_pdsch_vars[eNB_id]->llr[0],
+                             symbol,first_symbol_flag,nb_rb,
+                             adjust_G2(frame_parms,dlsch0_harq->rb_alloc,4,subframe,symbol),
+                             lte_ue_pdsch_vars[eNB_id]->llr128);
+        if (rx_type==rx_IC_dual_stream) {
+          dlsch_qpsk_16qam_llr(frame_parms,
+                               rxdataF_comp_ptr,
+                               lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,//i
+                               lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,//i
+                               lte_ue_pdsch_vars[eNB_id]->dl_ch_rho2_ext,
+                               lte_ue_pdsch_vars[eNB_id]->llr[1],
+                               symbol,first_symbol_flag,nb_rb,
+                               adjust_G2(frame_parms,dlsch1_harq->rb_alloc,2,subframe,symbol),
+                               lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
+        }
       }
-      else if (get_Qm(dlsch1_harq->mcs) == 4) { 
-	dlsch_qpsk_16qam_llr(frame_parms,
-			     lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			     lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[dlsch0_harq->round],
-			     lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1,
-			     lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext,
-			     lte_ue_pdsch_vars[eNB_id]->llr[0],
-			     symbol,first_symbol_flag,nb_rb,
-			     adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
-			     lte_ue_pdsch_vars[eNB_id]->llr128);
+      else if (i_mod == 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_rho_ext[harq_pid][round],
+			      lte_ue_pdsch_vars[eNB_id]->llr[0],
+			      symbol,first_symbol_flag,nb_rb,
+			      adjust_G2(frame_parms,dlsch0_harq->rb_alloc,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_rho2_ext,
+				lte_ue_pdsch_vars[eNB_id]->llr[1],
+				symbol,first_symbol_flag,nb_rb,
+				adjust_G2(frame_parms,dlsch1_harq->rb_alloc,4,subframe,symbol),
+				lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
+	}
       }
       else {
-	dlsch_qpsk_64qam_llr(frame_parms,
+	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_rho_ext[harq_pid][round],
+			      lte_ue_pdsch_vars[eNB_id]->llr[0],
+			      symbol,first_symbol_flag,nb_rb,
+			      adjust_G2(frame_parms,dlsch0_harq->rb_alloc,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_rho2_ext,
+				lte_ue_pdsch_vars[eNB_id]->llr[1],
+				symbol,first_symbol_flag,nb_rb,
+				adjust_G2(frame_parms,dlsch1_harq->rb_alloc,6,subframe,symbol),
+				lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
+	}
+      }
+    }
+    break;
+  case 6 :
+    if (rx_type==rx_standard) {
+      dlsch_64qam_llr(frame_parms,
+                      lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
+                      lte_ue_pdsch_vars[eNB_id]->llr[0],
+                      lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
+                      lte_ue_pdsch_vars[eNB_id]->dl_ch_magb0,
+                      symbol,first_symbol_flag,nb_rb,
+                      adjust_G2(frame_parms,dlsch0_harq->rb_alloc,6,subframe,symbol),
+                      lte_ue_pdsch_vars[eNB_id]->llr128);
+    }
+    else if ((rx_type==rx_IC_single_stream) || (rx_type==rx_IC_dual_stream)) {
+      if (i_mod == 2) {              
+	dlsch_64qam_qpsk_llr(frame_parms,
 			     lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			     lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[dlsch0_harq->round],
-			     lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1,
-			     lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext,
+			     rxdataF_comp_ptr,//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[0],
 			     symbol,first_symbol_flag,nb_rb,
-			     adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
+			     adjust_G2(frame_parms,dlsch0_harq->rb_alloc,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_rho2_ext,
+			       lte_ue_pdsch_vars[eNB_id]->llr[1],
+			       symbol,first_symbol_flag,nb_rb,
+			       adjust_G2(frame_parms,dlsch1_harq->rb_alloc,2,subframe,symbol),
+			       lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
+	}
+      }
+      else if (i_mod == 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_rho_ext[harq_pid][round],
+			      lte_ue_pdsch_vars[eNB_id]->llr[0],
+			      symbol,first_symbol_flag,nb_rb,
+			      adjust_G2(frame_parms,dlsch0_harq->rb_alloc,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_rho2_ext,
+				lte_ue_pdsch_vars[eNB_id]->llr[1],
+				symbol,first_symbol_flag,nb_rb,
+				adjust_G2(frame_parms,dlsch1_harq->rb_alloc,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_rho_ext[harq_pid][round],
+			      lte_ue_pdsch_vars[eNB_id]->llr[0],
+			      symbol,first_symbol_flag,nb_rb,
+			      adjust_G2(frame_parms,dlsch0_harq->rb_alloc,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_rho2_ext,
+				lte_ue_pdsch_vars[eNB_id]->llr[1],
+				symbol,first_symbol_flag,nb_rb,
+				adjust_G2(frame_parms,dlsch1_harq->rb_alloc,6,subframe,symbol),
+				lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
+	}
+      }
     }
     break;
-  case 4 :
-    if (dual_stream_flag == 0) {
-      dlsch_16qam_llr(frame_parms,
-		      lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-		      lte_ue_pdsch_vars[eNB_id]->llr[0],
-		      lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-		      symbol,first_symbol_flag,nb_rb,
-		      adjust_G2(frame_parms,dlsch0_harq->rb_alloc,4,subframe,symbol),
-		      lte_ue_pdsch_vars[eNB_id]->llr128);
+  default:
+    LOG_W(PHY,"rx_dlsch.c : Unknown mod_order!!!!\n");
+    return(-1);
+    break;
+  }
+
+  switch (get_Qm(dlsch1_harq->mcs)) {
+  case 2 : 
+    if (rx_type==rx_standard) {
+        dlsch_qpsk_llr(frame_parms,
+                       rxdataF_comp_ptr,
+                       lte_ue_pdsch_vars[eNB_id]->llr[1],
+                       symbol,first_symbol_flag,nb_rb,
+                       adjust_G2(frame_parms,dlsch1_harq->rb_alloc,2,subframe,symbol),
+                       lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
     }
-    else if (i_mod == 2) {
-      dlsch_16qam_qpsk_llr(frame_parms,
-			   lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			   lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0,
-			   lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-			   lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext,
-			   lte_ue_pdsch_vars[eNB_id]->llr[0],
-			   symbol,first_symbol_flag,nb_rb,
-			   adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
-			   lte_ue_pdsch_vars[eNB_id]->llr128);
-    } 
-    else if (i_mod == 4) {
-      dlsch_16qam_16qam_llr(frame_parms,
-			    lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			    lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0,
-			    lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-			    lte_ue_pdsch_vars[eNB_id_i]->dl_ch_mag0,
-			    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext,
-			    lte_ue_pdsch_vars[eNB_id]->llr[0],
-			    symbol,first_symbol_flag,nb_rb,
-			    adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
-			    lte_ue_pdsch_vars[eNB_id]->llr128);
-    } else {
-      dlsch_16qam_64qam_llr(frame_parms,
-			    lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			    lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0,
-			    lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-			    lte_ue_pdsch_vars[eNB_id_i]->dl_ch_mag0,
-			    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext,
-			    lte_ue_pdsch_vars[eNB_id]->llr[0],
-			    symbol,first_symbol_flag,nb_rb,
-			    adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
-			    lte_ue_pdsch_vars[eNB_id]->llr128);
+    break;
+  case 4:
+    if (rx_type==rx_standard) {
+      dlsch_16qam_llr(frame_parms,
+                      rxdataF_comp_ptr,
+                      lte_ue_pdsch_vars[eNB_id]->llr[1],
+                      lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1,
+                      symbol,first_symbol_flag,nb_rb,
+                      adjust_G2(frame_parms,dlsch1_harq->rb_alloc,4,subframe,symbol),
+                      lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
     }
     break;
   case 6 :
-    if (dual_stream_flag == 0) {
+    if (rx_type==rx_standard) {
       dlsch_64qam_llr(frame_parms,
-		      lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-		      lte_ue_pdsch_vars[eNB_id]->llr[0],
-		      lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-		      lte_ue_pdsch_vars[eNB_id]->dl_ch_magb0,
-		      symbol,first_symbol_flag,nb_rb,
-		      adjust_G2(frame_parms,dlsch0_harq->rb_alloc,6,subframe,symbol),
-		      lte_ue_pdsch_vars[eNB_id]->llr128);
-    }
-    else if (i_mod == 2) {              
-      dlsch_64qam_qpsk_llr(frame_parms,
-			   lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			   lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0,
-			   lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-			   lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext,
-			   lte_ue_pdsch_vars[eNB_id]->llr[0],
-			   symbol,first_symbol_flag,nb_rb,
-			   adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
-			   lte_ue_pdsch_vars[eNB_id]->llr128);
-    }
-    else if (i_mod == 4) {
-      dlsch_64qam_16qam_llr(frame_parms,
-			    lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			    lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0,
-			    lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-			    lte_ue_pdsch_vars[eNB_id_i]->dl_ch_mag0,
-			    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext,
-			    lte_ue_pdsch_vars[eNB_id]->llr[0],
-			    symbol,first_symbol_flag,nb_rb,
-			    adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
-			    lte_ue_pdsch_vars[eNB_id]->llr128);
-	
-    }
-    else {	  
-      dlsch_64qam_64qam_llr(frame_parms,
-			    lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0,
-			    lte_ue_pdsch_vars[eNB_id_i]->rxdataF_comp0,
-			    lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0,
-			    lte_ue_pdsch_vars[eNB_id_i]->dl_ch_mag0,
-			    lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext,
-			    lte_ue_pdsch_vars[eNB_id]->llr[0],
-			    symbol,first_symbol_flag,nb_rb,
-			    adjust_G2(frame_parms,dlsch0_harq->rb_alloc,2,subframe,symbol),
-			    lte_ue_pdsch_vars[eNB_id]->llr128);
+                      rxdataF_comp_ptr,
+                      lte_ue_pdsch_vars[eNB_id]->llr[1],
+                      lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1,
+                      lte_ue_pdsch_vars[eNB_id]->dl_ch_magb1,
+                      symbol,first_symbol_flag,nb_rb,
+                      adjust_G2(frame_parms,dlsch1_harq->rb_alloc,6,subframe,symbol),
+                      lte_ue_pdsch_vars[eNB_id]->llr128_2ndstream);
     }
     break;
   default:
@@ -780,6 +948,7 @@ int rx_pdsch(PHY_VARS_UE *phy_vars_ue,
     break;
   }
 
+
   return(0);    
 }
 
@@ -822,7 +991,7 @@ void dlsch_channel_compensation(int **rxdataF_ext,
       QAM_amp128b = _mm_setzero_si128();
     }    
     else if (mod_order == 6) {
-      QAM_amp128  = _mm_set1_epi16(QAM64_n1); // 
+      QAM_amp128  = _mm_set1_epi16(QAM64_n1); 
       QAM_amp128b = _mm_set1_epi16(QAM64_n2);
     }
     
@@ -838,128 +1007,128 @@ void dlsch_channel_compensation(int **rxdataF_ext,
 
 
       for (rb=0;rb<nb_rb;rb++) {
-	if (mod_order>2) {  
-	  // get channel amplitude if not QPSK
+        if (mod_order>2) {  
+          // get channel amplitude if not QPSK
                 
-	  mmtmpD0 = _mm_madd_epi16(dl_ch128[0],dl_ch128[0]);
-	  mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+          mmtmpD0 = _mm_madd_epi16(dl_ch128[0],dl_ch128[0]);
+          mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
                 
-	  mmtmpD1 = _mm_madd_epi16(dl_ch128[1],dl_ch128[1]);
-	  mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+          mmtmpD1 = _mm_madd_epi16(dl_ch128[1],dl_ch128[1]);
+          mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
                 
-	  mmtmpD0 = _mm_packs_epi32(mmtmpD0,mmtmpD1);
+          mmtmpD0 = _mm_packs_epi32(mmtmpD0,mmtmpD1);
                 
-	  // store channel magnitude here in a new field of dlsch
+          // store channel magnitude here in a new field of dlsch
                 
-	  dl_ch_mag128[0] = _mm_unpacklo_epi16(mmtmpD0,mmtmpD0);
-	  dl_ch_mag128b[0] = dl_ch_mag128[0];
-	  dl_ch_mag128[0] = _mm_mulhi_epi16(dl_ch_mag128[0],QAM_amp128);
-	  dl_ch_mag128[0] = _mm_slli_epi16(dl_ch_mag128[0],1);
+          dl_ch_mag128[0] = _mm_unpacklo_epi16(mmtmpD0,mmtmpD0);
+          dl_ch_mag128b[0] = dl_ch_mag128[0];
+          dl_ch_mag128[0] = _mm_mulhi_epi16(dl_ch_mag128[0],QAM_amp128);
+          dl_ch_mag128[0] = _mm_slli_epi16(dl_ch_mag128[0],1);
                 
-	  dl_ch_mag128[1] = _mm_unpackhi_epi16(mmtmpD0,mmtmpD0);
-	  dl_ch_mag128b[1] = dl_ch_mag128[1];
-	  dl_ch_mag128[1] = _mm_mulhi_epi16(dl_ch_mag128[1],QAM_amp128);
-	  dl_ch_mag128[1] = _mm_slli_epi16(dl_ch_mag128[1],1);
+          dl_ch_mag128[1] = _mm_unpackhi_epi16(mmtmpD0,mmtmpD0);
+          dl_ch_mag128b[1] = dl_ch_mag128[1];
+          dl_ch_mag128[1] = _mm_mulhi_epi16(dl_ch_mag128[1],QAM_amp128);
+          dl_ch_mag128[1] = _mm_slli_epi16(dl_ch_mag128[1],1);
                 
-	  if (pilots==0) {
-	    mmtmpD0 = _mm_madd_epi16(dl_ch128[2],dl_ch128[2]);
-	    mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-	    mmtmpD1 = _mm_packs_epi32(mmtmpD0,mmtmpD0);
+          if (pilots==0) {
+            mmtmpD0 = _mm_madd_epi16(dl_ch128[2],dl_ch128[2]);
+            mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+            mmtmpD1 = _mm_packs_epi32(mmtmpD0,mmtmpD0);
                     
-	    dl_ch_mag128[2] = _mm_unpacklo_epi16(mmtmpD1,mmtmpD1);
-	    dl_ch_mag128b[2] = dl_ch_mag128[2];
+            dl_ch_mag128[2] = _mm_unpacklo_epi16(mmtmpD1,mmtmpD1);
+            dl_ch_mag128b[2] = dl_ch_mag128[2];
                     
-	    dl_ch_mag128[2] = _mm_mulhi_epi16(dl_ch_mag128[2],QAM_amp128);
-	    dl_ch_mag128[2] = _mm_slli_epi16(dl_ch_mag128[2],1);	  
-	  }
+            dl_ch_mag128[2] = _mm_mulhi_epi16(dl_ch_mag128[2],QAM_amp128);
+            dl_ch_mag128[2] = _mm_slli_epi16(dl_ch_mag128[2],1);          
+          }
                 
-	  dl_ch_mag128b[0] = _mm_mulhi_epi16(dl_ch_mag128b[0],QAM_amp128b);
-	  dl_ch_mag128b[0] = _mm_slli_epi16(dl_ch_mag128b[0],1);
+          dl_ch_mag128b[0] = _mm_mulhi_epi16(dl_ch_mag128b[0],QAM_amp128b);
+          dl_ch_mag128b[0] = _mm_slli_epi16(dl_ch_mag128b[0],1);
                 
                 
-	  dl_ch_mag128b[1] = _mm_mulhi_epi16(dl_ch_mag128b[1],QAM_amp128b);
-	  dl_ch_mag128b[1] = _mm_slli_epi16(dl_ch_mag128b[1],1);
+          dl_ch_mag128b[1] = _mm_mulhi_epi16(dl_ch_mag128b[1],QAM_amp128b);
+          dl_ch_mag128b[1] = _mm_slli_epi16(dl_ch_mag128b[1],1);
                 
-	  if (pilots==0) {
-	    dl_ch_mag128b[2] = _mm_mulhi_epi16(dl_ch_mag128b[2],QAM_amp128b);
-	    dl_ch_mag128b[2] = _mm_slli_epi16(dl_ch_mag128b[2],1);	  
-	  }
-	}
-	
-	// multiply by conjugated channel
-	mmtmpD0 = _mm_madd_epi16(dl_ch128[0],rxdataF128[0]);
-	//	print_ints("re",&mmtmpD0);
+          if (pilots==0) {
+            dl_ch_mag128b[2] = _mm_mulhi_epi16(dl_ch_mag128b[2],QAM_amp128b);
+            dl_ch_mag128b[2] = _mm_slli_epi16(dl_ch_mag128b[2],1);        
+          }
+        }
+        
+        // multiply by conjugated channel
+        mmtmpD0 = _mm_madd_epi16(dl_ch128[0],rxdataF128[0]);
+        //      print_ints("re",&mmtmpD0);
             
-	// mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
-	mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[0],_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)&conjugate[0]);
-	//	print_ints("im",&mmtmpD1);
-	mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[0]);
-	// mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
-	mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-	//	print_ints("re(shift)",&mmtmpD0);
-	mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
-	//	print_ints("im(shift)",&mmtmpD1);
-	mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
-	mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
-	//       	print_ints("c0",&mmtmpD2);
-	//	print_ints("c1",&mmtmpD3);
-	rxdataF_comp128[0] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
-	//	print_shorts("rx:",rxdataF128);
-	//	print_shorts("ch:",dl_ch128);
-	//	print_shorts("pack:",rxdataF_comp128);
+        // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+        mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[0],_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)&conjugate[0]);
+        //      print_ints("im",&mmtmpD1);
+        mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[0]);
+        // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+        mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        //      print_ints("re(shift)",&mmtmpD0);
+        mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+        //      print_ints("im(shift)",&mmtmpD1);
+        mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+        mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+        //              print_ints("c0",&mmtmpD2);
+        //      print_ints("c1",&mmtmpD3);
+        rxdataF_comp128[0] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
+        //      print_shorts("rx:",rxdataF128);
+        //      print_shorts("ch:",dl_ch128);
+        //      print_shorts("pack:",rxdataF_comp128);
             
-	// multiply by conjugated channel
-	mmtmpD0 = _mm_madd_epi16(dl_ch128[1],rxdataF128[1]);
-	// mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
-	mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[1],_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
-	mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[1]);
-	// mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
-	mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-	mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
-	mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
-	mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+        // multiply by conjugated channel
+        mmtmpD0 = _mm_madd_epi16(dl_ch128[1],rxdataF128[1]);
+        // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+        mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[1],_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
+        mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[1]);
+        // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+        mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+        mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+        mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
             
-	rxdataF_comp128[1] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
-	//	print_shorts("rx:",rxdataF128+1);
-	//	print_shorts("ch:",dl_ch128+1);
-	//	print_shorts("pack:",rxdataF_comp128+1);	
+        rxdataF_comp128[1] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
+        //      print_shorts("rx:",rxdataF128+1);
+        //      print_shorts("ch:",dl_ch128+1);
+        //      print_shorts("pack:",rxdataF_comp128+1);        
             
-	if (pilots==0) {
-	  // multiply by conjugated channel
-	  mmtmpD0 = _mm_madd_epi16(dl_ch128[2],rxdataF128[2]);
-	  // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
-	  mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[2],_MM_SHUFFLE(2,3,0,1));
-	  mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
-	  mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
-	  mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[2]);
-	  // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
-	  mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-	  mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
-	  mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
-	  mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+        if (pilots==0) {
+          // multiply by conjugated channel
+          mmtmpD0 = _mm_madd_epi16(dl_ch128[2],rxdataF128[2]);
+          // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+          mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[2],_MM_SHUFFLE(2,3,0,1));
+          mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+          mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
+          mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[2]);
+          // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+          mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+          mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+          mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+          mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
                 
-	  rxdataF_comp128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
-	  //	print_shorts("rx:",rxdataF128+2);
-	  //	print_shorts("ch:",dl_ch128+2);
-	  //      	print_shorts("pack:",rxdataF_comp128+2);
+          rxdataF_comp128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
+          //    print_shorts("rx:",rxdataF128+2);
+          //    print_shorts("ch:",dl_ch128+2);
+          //            print_shorts("pack:",rxdataF_comp128+2);
                 
-	  dl_ch128+=3;
-	  dl_ch_mag128+=3;
-	  dl_ch_mag128b+=3;
-	  rxdataF128+=3;
-	  rxdataF_comp128+=3;
-	}
-	else { // we have a smaller PDSCH in symbols with pilots so skip last group of 4 REs and increment less
-	  dl_ch128+=2;
-	  dl_ch_mag128+=2;
-	  dl_ch_mag128b+=2;
-	  rxdataF128+=2;
-	  rxdataF_comp128+=2;
-	}
+          dl_ch128+=3;
+          dl_ch_mag128+=3;
+          dl_ch_mag128b+=3;
+          rxdataF128+=3;
+          rxdataF_comp128+=3;
+        }
+        else { // we have a smaller PDSCH in symbols with pilots so skip last group of 4 REs and increment less
+          dl_ch128+=2;
+          dl_ch_mag128+=2;
+          dl_ch_mag128b+=2;
+          rxdataF128+=2;
+          rxdataF_comp128+=2;
+        }
             
       }
     }
@@ -974,75 +1143,75 @@ void dlsch_channel_compensation(int **rxdataF_ext,
       dl_ch128_2    = (__m128i *)&dl_ch_estimates_ext[2+aarx][symbol*frame_parms->N_RB_DL*12];
           
       for (rb=0;rb<nb_rb;rb++) {
-	// multiply by conjugated channel
-	mmtmpD0 = _mm_madd_epi16(dl_ch128[0],dl_ch128_2[0]);
-	//	print_ints("re",&mmtmpD0);
+        // multiply by conjugated channel
+        mmtmpD0 = _mm_madd_epi16(dl_ch128[0],dl_ch128_2[0]);
+        //      print_ints("re",&mmtmpD0);
               
-	// mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
-	mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[0],_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)&conjugate[0]);
-	//	print_ints("im",&mmtmpD1);
-	mmtmpD1 = _mm_madd_epi16(mmtmpD1,dl_ch128_2[0]);
-	// mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
-	mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-	//	print_ints("re(shift)",&mmtmpD0);
-	mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
-	//	print_ints("im(shift)",&mmtmpD1);
-	mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
-	mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
-	//       	print_ints("c0",&mmtmpD2);
-	//	print_ints("c1",&mmtmpD3);
-	rho128[0] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
+        // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+        mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[0],_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)&conjugate[0]);
+        //      print_ints("im",&mmtmpD1);
+        mmtmpD1 = _mm_madd_epi16(mmtmpD1,dl_ch128_2[0]);
+        // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+        mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        //      print_ints("re(shift)",&mmtmpD0);
+        mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+        //      print_ints("im(shift)",&mmtmpD1);
+        mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+        mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+        //              print_ints("c0",&mmtmpD2);
+        //      print_ints("c1",&mmtmpD3);
+        rho128[0] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
               
-	//print_shorts("rx:",dl_ch128_2);
-	//print_shorts("ch:",dl_ch128);
-	//print_shorts("pack:",rho128);
+        //print_shorts("rx:",dl_ch128_2);
+        //print_shorts("ch:",dl_ch128);
+        //print_shorts("pack:",rho128);
               
-	// multiply by conjugated channel
-	mmtmpD0 = _mm_madd_epi16(dl_ch128[1],dl_ch128_2[1]);
-	// mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
-	mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[1],_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
-	mmtmpD1 = _mm_madd_epi16(mmtmpD1,dl_ch128_2[1]);
-	// mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
-	mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-	mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
-	mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
-	mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+        // multiply by conjugated channel
+        mmtmpD0 = _mm_madd_epi16(dl_ch128[1],dl_ch128_2[1]);
+        // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+        mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[1],_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
+        mmtmpD1 = _mm_madd_epi16(mmtmpD1,dl_ch128_2[1]);
+        // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+        mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+        mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+        mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
 
-	
-	rho128[1] =_mm_packs_epi32(mmtmpD2,mmtmpD3);
-	//print_shorts("rx:",dl_ch128_2+1);
-	//print_shorts("ch:",dl_ch128+1);
-	//print_shorts("pack:",rho128+1);	
-	// multiply by conjugated channel
-	mmtmpD0 = _mm_madd_epi16(dl_ch128[2],dl_ch128_2[2]);
-	// mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
-	mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[2],_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
-	mmtmpD1 = _mm_madd_epi16(mmtmpD1,dl_ch128_2[2]);
-	// mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
-	mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-	mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
-	mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
-	mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+        
+        rho128[1] =_mm_packs_epi32(mmtmpD2,mmtmpD3);
+        //print_shorts("rx:",dl_ch128_2+1);
+        //print_shorts("ch:",dl_ch128+1);
+        //print_shorts("pack:",rho128+1);       
+        // multiply by conjugated channel
+        mmtmpD0 = _mm_madd_epi16(dl_ch128[2],dl_ch128_2[2]);
+        // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+        mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[2],_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
+        mmtmpD1 = _mm_madd_epi16(mmtmpD1,dl_ch128_2[2]);
+        // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+        mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+        mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+        mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
               
-	rho128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
-	//print_shorts("rx:",dl_ch128_2+2);
-	//print_shorts("ch:",dl_ch128+2);
-	//print_shorts("pack:",rho128+2);
+        rho128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
+        //print_shorts("rx:",dl_ch128_2+2);
+        //print_shorts("ch:",dl_ch128+2);
+        //print_shorts("pack:",rho128+2);
               
-	dl_ch128+=3;
-	dl_ch128_2+=3;
-	rho128+=3;
+        dl_ch128+=3;
+        dl_ch128_2+=3;
+        rho128+=3;
               
-      }	
+      } 
           
       if (first_symbol_flag==1) {
-	phy_measurements->rx_correlation[0][aarx] = signal_energy(&rho[aarx][symbol*frame_parms->N_RB_DL*12],rb*12);
+        phy_measurements->rx_correlation[0][aarx] = signal_energy(&rho[aarx][symbol*frame_parms->N_RB_DL*12],rb*12);
       }           
     }      
   }
@@ -1134,26 +1303,44 @@ void prec2A_TM3_128(__m128i *ch0,__m128i *ch1) {
 
 void prec2A_TM4_128(int pmi,__m128i *ch0,__m128i *ch1) {
   
-  __m128i amp;
-  amp = _mm_set1_epi16(ONE_OVER_SQRT2_Q15);
-  __m128i tmp1;
+  // __m128i amp;
+  // amp = _mm_set1_epi16(ONE_OVER_SQRT2_Q15);
+  __m128i tmp0,tmp1;
   
-  if (pmi == 0) {
-    ch0[0] = _mm_adds_epi16(ch0[0],ch1[0]);
-    ch1[0] = _mm_subs_epi16(ch0[0],ch1[0]);
+  //print_shorts("prec2A_TM4 ch0 (before):",ch0);
+  //print_shorts("prec2A_TM4 ch1 (before):",ch1);
+
+  if (pmi == 0) { //[1 1;1 -1]
+    tmp0 = ch0[0];
+    tmp1 = ch1[0];
+    ch0[0] = _mm_adds_epi16(tmp0,tmp1);
+    ch1[0] = _mm_subs_epi16(tmp0,tmp1);
   }
   else {
+    tmp0 = ch0[0];
     tmp1   = _mm_sign_epi16(ch1[0],*(__m128i*)&conjugate[0]);
     tmp1   = _mm_shufflelo_epi16(tmp1,_MM_SHUFFLE(2,3,0,1));
     tmp1   = _mm_shufflehi_epi16(tmp1,_MM_SHUFFLE(2,3,0,1));
-    ch0[0] = _mm_subs_epi16(ch0[0],tmp1);
-    ch1[0] = _mm_subs_epi16(ch0[0],tmp1);
+    ch0[0] = _mm_subs_epi16(tmp0,tmp1);
+    ch1[0] = _mm_subs_epi16(tmp0,tmp1);
   }
-  ch0[0] = _mm_mulhi_epi16(ch0[0],amp);
-  ch0[0] = _mm_slli_epi16(ch0[0],1);
-  ch1[0] = _mm_mulhi_epi16(ch1[0],amp);
-  ch1[0] = _mm_slli_epi16(ch1[0],1);
 
+  //print_shorts("prec2A_TM4 ch0 (middle):",ch0);
+  //print_shorts("prec2A_TM4 ch1 (middle):",ch1);
+
+  //ch0[0] = _mm_mulhi_epi16(ch0[0],amp);
+  //ch0[0] = _mm_slli_epi16(ch0[0],1);
+  //ch1[0] = _mm_mulhi_epi16(ch1[0],amp);
+  //ch1[0] = _mm_slli_epi16(ch1[0],1);
+
+  //print_shorts("prec2A_TM4 ch0 (end):",ch0);
+  //print_shorts("prec2A_TM4 ch1 (end):",ch1);
+  ch0[0] = _mm_srai_epi16(ch0[0],1); //divide by 2
+  ch1[0] = _mm_srai_epi16(ch1[0],1); //divide by 2
+
+
+ // print_shorts("prec2A_TM4 ch0 (end):",ch0);
+  //print_shorts("prec2A_TM4 ch1 (end):",ch1);
 }
 
 void dlsch_channel_compensation_TM56(int **rxdataF_ext,
@@ -1216,82 +1403,82 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
       prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128[1],&dl_ch1_128[1]);
 
       if (pilots==0) {
-	prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128[2],&dl_ch1_128[2]); 
+        prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128[2],&dl_ch1_128[2]); 
       }
 
       if (mod_order>2) {  
-	// get channel amplitude if not QPSK
-	
-	mmtmpD0 = _mm_madd_epi16(dl_ch0_128[0],dl_ch0_128[0]);	
-	mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        // get channel amplitude if not QPSK
+        
+        mmtmpD0 = _mm_madd_epi16(dl_ch0_128[0],dl_ch0_128[0]);  
+        mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
                 
-	mmtmpD1 = _mm_madd_epi16(dl_ch0_128[1],dl_ch0_128[1]);
-	mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+        mmtmpD1 = _mm_madd_epi16(dl_ch0_128[1],dl_ch0_128[1]);
+        mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
                 
-	mmtmpD0 = _mm_packs_epi32(mmtmpD0,mmtmpD1);
+        mmtmpD0 = _mm_packs_epi32(mmtmpD0,mmtmpD1);
                 
-	dl_ch_mag128[0] = _mm_unpacklo_epi16(mmtmpD0,mmtmpD0);
-	dl_ch_mag128b[0] = dl_ch_mag128[0];
-	dl_ch_mag128[0] = _mm_mulhi_epi16(dl_ch_mag128[0],QAM_amp128);
-	dl_ch_mag128[0] = _mm_slli_epi16(dl_ch_mag128[0],1);
+        dl_ch_mag128[0] = _mm_unpacklo_epi16(mmtmpD0,mmtmpD0);
+        dl_ch_mag128b[0] = dl_ch_mag128[0];
+        dl_ch_mag128[0] = _mm_mulhi_epi16(dl_ch_mag128[0],QAM_amp128);
+        dl_ch_mag128[0] = _mm_slli_epi16(dl_ch_mag128[0],1);
                 
-	//print_shorts("dl_ch_mag128[0]=",&dl_ch_mag128[0]);
+        //print_shorts("dl_ch_mag128[0]=",&dl_ch_mag128[0]);
                 
-	dl_ch_mag128[1] = _mm_unpackhi_epi16(mmtmpD0,mmtmpD0);
-	dl_ch_mag128b[1] = dl_ch_mag128[1];
-	dl_ch_mag128[1] = _mm_mulhi_epi16(dl_ch_mag128[1],QAM_amp128);
-	dl_ch_mag128[1] = _mm_slli_epi16(dl_ch_mag128[1],1);
+        dl_ch_mag128[1] = _mm_unpackhi_epi16(mmtmpD0,mmtmpD0);
+        dl_ch_mag128b[1] = dl_ch_mag128[1];
+        dl_ch_mag128[1] = _mm_mulhi_epi16(dl_ch_mag128[1],QAM_amp128);
+        dl_ch_mag128[1] = _mm_slli_epi16(dl_ch_mag128[1],1);
                 
-	if (pilots==0) {
-	  mmtmpD0 = _mm_madd_epi16(dl_ch0_128[2],dl_ch0_128[2]);
-	  mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        if (pilots==0) {
+          mmtmpD0 = _mm_madd_epi16(dl_ch0_128[2],dl_ch0_128[2]);
+          mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
                     
-	  mmtmpD1 = _mm_packs_epi32(mmtmpD0,mmtmpD0);
+          mmtmpD1 = _mm_packs_epi32(mmtmpD0,mmtmpD0);
                     
-	  dl_ch_mag128[2] = _mm_unpacklo_epi16(mmtmpD1,mmtmpD1);
-	  dl_ch_mag128b[2] = dl_ch_mag128[2];
+          dl_ch_mag128[2] = _mm_unpacklo_epi16(mmtmpD1,mmtmpD1);
+          dl_ch_mag128b[2] = dl_ch_mag128[2];
                     
-	  dl_ch_mag128[2] = _mm_mulhi_epi16(dl_ch_mag128[2],QAM_amp128);
-	  dl_ch_mag128[2] = _mm_slli_epi16(dl_ch_mag128[2],1);	  
-	}
+          dl_ch_mag128[2] = _mm_mulhi_epi16(dl_ch_mag128[2],QAM_amp128);
+          dl_ch_mag128[2] = _mm_slli_epi16(dl_ch_mag128[2],1);    
+        }
                 
-	dl_ch_mag128b[0] = _mm_mulhi_epi16(dl_ch_mag128b[0],QAM_amp128b);
-	dl_ch_mag128b[0] = _mm_slli_epi16(dl_ch_mag128b[0],1);
+        dl_ch_mag128b[0] = _mm_mulhi_epi16(dl_ch_mag128b[0],QAM_amp128b);
+        dl_ch_mag128b[0] = _mm_slli_epi16(dl_ch_mag128b[0],1);
                 
-	//print_shorts("dl_ch_mag128b[0]=",&dl_ch_mag128b[0]);
+        //print_shorts("dl_ch_mag128b[0]=",&dl_ch_mag128b[0]);
                 
-	dl_ch_mag128b[1] = _mm_mulhi_epi16(dl_ch_mag128b[1],QAM_amp128b);
-	dl_ch_mag128b[1] = _mm_slli_epi16(dl_ch_mag128b[1],1);
+        dl_ch_mag128b[1] = _mm_mulhi_epi16(dl_ch_mag128b[1],QAM_amp128b);
+        dl_ch_mag128b[1] = _mm_slli_epi16(dl_ch_mag128b[1],1);
                 
-	if (pilots==0) {
-	  dl_ch_mag128b[2] = _mm_mulhi_epi16(dl_ch_mag128b[2],QAM_amp128b);
-	  dl_ch_mag128b[2] = _mm_slli_epi16(dl_ch_mag128b[2],1);	  
-	}
+        if (pilots==0) {
+          dl_ch_mag128b[2] = _mm_mulhi_epi16(dl_ch_mag128b[2],QAM_amp128b);
+          dl_ch_mag128b[2] = _mm_slli_epi16(dl_ch_mag128b[2],1);          
+        }
       }
 
       // MF multiply by conjugated channel
       mmtmpD0 = _mm_madd_epi16(dl_ch0_128[0],rxdataF128[0]);
-      //	print_ints("re",&mmtmpD0);
+      //        print_ints("re",&mmtmpD0);
             
       // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
       mmtmpD1 = _mm_shufflelo_epi16(dl_ch0_128[0],_MM_SHUFFLE(2,3,0,1));
       mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
       mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)&conjugate[0]);
-      //	print_ints("im",&mmtmpD1);
+      //        print_ints("im",&mmtmpD1);
       mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[0]);
       // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
       mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-      //	print_ints("re(shift)",&mmtmpD0);
+      //        print_ints("re(shift)",&mmtmpD0);
       mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
-      //	print_ints("im(shift)",&mmtmpD1);
+      //        print_ints("im(shift)",&mmtmpD1);
       mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
       mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
-      //       	print_ints("c0",&mmtmpD2);
-      //	print_ints("c1",&mmtmpD3);
+      //        print_ints("c0",&mmtmpD2);
+      //        print_ints("c1",&mmtmpD3);
       rxdataF_comp128[0] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
-      //	print_shorts("rx:",rxdataF128);
-      //	print_shorts("ch:",dl_ch128);
-      //	print_shorts("pack:",rxdataF_comp128);
+      //        print_shorts("rx:",rxdataF128);
+      //        print_shorts("ch:",dl_ch128);
+      //        print_shorts("pack:",rxdataF_comp128);
             
       // multiply by conjugated channel
       mmtmpD0 = _mm_madd_epi16(dl_ch0_128[1],rxdataF128[1]);
@@ -1307,71 +1494,73 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
       mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
             
       rxdataF_comp128[1] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
-      //	print_shorts("rx:",rxdataF128+1);
-      //	print_shorts("ch:",dl_ch128+1);
-      //	print_shorts("pack:",rxdataF_comp128+1);	
+      //        print_shorts("rx:",rxdataF128+1);
+      //        print_shorts("ch:",dl_ch128+1);
+      //        print_shorts("pack:",rxdataF_comp128+1);        
             
       if (pilots==0) {
-	// multiply by conjugated channel
-	mmtmpD0 = _mm_madd_epi16(dl_ch0_128[2],rxdataF128[2]);
-	// mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
-	mmtmpD1 = _mm_shufflelo_epi16(dl_ch0_128[2],_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
-	mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[2]);
-	// mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
-	mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-	mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
-	mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
-	mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+        // multiply by conjugated channel
+        mmtmpD0 = _mm_madd_epi16(dl_ch0_128[2],rxdataF128[2]);
+        // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+        mmtmpD1 = _mm_shufflelo_epi16(dl_ch0_128[2],_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
+        mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[2]);
+        // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+        mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+        mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+        mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
                 
-	rxdataF_comp128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
-	//	print_shorts("rx:",rxdataF128+2);
-	//	print_shorts("ch:",dl_ch128+2);
-	//      	print_shorts("pack:",rxdataF_comp128+2);
+        rxdataF_comp128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
+        //      print_shorts("rx:",rxdataF128+2);
+        //      print_shorts("ch:",dl_ch128+2);
+        //              print_shorts("pack:",rxdataF_comp128+2);
                 
-	dl_ch0_128+=3;
-	dl_ch1_128+=3;
-	dl_ch_mag128+=3;
-	dl_ch_mag128b+=3;
-	rxdataF128+=3;
-	rxdataF_comp128+=3;
+        dl_ch0_128+=3;
+        dl_ch1_128+=3;
+        dl_ch_mag128+=3;
+        dl_ch_mag128b+=3;
+        rxdataF128+=3;
+        rxdataF_comp128+=3;
       }
       else {
-	dl_ch0_128+=2;
-	dl_ch1_128+=2;
-	dl_ch_mag128+=2;
-	dl_ch_mag128b+=2;
-	rxdataF128+=2;
-	rxdataF_comp128+=2;
+        dl_ch0_128+=2;
+        dl_ch1_128+=2;
+        dl_ch_mag128+=2;
+        dl_ch_mag128b+=2;
+        rxdataF128+=2;
+        rxdataF_comp128+=2;
       }
     }
         
     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))*rx_power_correction) - (phy_measurements->n0_power[aarx]));
+                                                     (nb_rb*Nre))*rx_power_correction) - (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);
-	
+        
   //printf("eNB_id %d, symbol %d: precoded CQI %d dB\n",eNB_id,symbol,
-  //	 phy_measurements->precoded_cqi_dB[eNB_id][0]);
+  //     phy_measurements->precoded_cqi_dB[eNB_id][0]);
     
   _mm_empty();
   _m_empty();  
 }    
 
-void dlsch_channel_compensation_TM3(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 round,
-				    unsigned short nb_rb,
-				    unsigned char output_shift) {
+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_shift) {
   
   unsigned short rb,Nre;
   __m128i *dl_ch0_128,*dl_ch1_128,*dl_ch_mag0_128,*dl_ch_mag1_128,*dl_ch_mag0_128b,*dl_ch_mag1_128b,*rxdataF128,*rxdataF_comp0_128,*rxdataF_comp1_128;
@@ -1385,7 +1574,7 @@ void dlsch_channel_compensation_TM3(LTE_DL_FRAME_PARMS *frame_parms,
   int **dl_ch_magb0           = lte_ue_pdsch_vars->dl_ch_magb0;
   int **dl_ch_magb1           = lte_ue_pdsch_vars->dl_ch_magb1;
   int **rxdataF_comp0         = lte_ue_pdsch_vars->rxdataF_comp0;
-  int **rxdataF_comp1         = lte_ue_pdsch_vars->rxdataF_comp1[round]; //?
+  int **rxdataF_comp1         = lte_ue_pdsch_vars->rxdataF_comp1[harq_pid][round];
   __m128i mmtmpD0,mmtmpD1,mmtmpD2,mmtmpD3,QAM_amp0_128,QAM_amp0_128b,QAM_amp1_128,QAM_amp1_128b;   
     
 
@@ -1396,7 +1585,7 @@ void dlsch_channel_compensation_TM3(LTE_DL_FRAME_PARMS *frame_parms,
 
   rx_power_correction = 1;
     
-  //printf("comp prec: symbol %d, pilots %d\n",symbol, pilots);
+ // printf("comp prec: symbol %d, pilots %d\n",symbol, pilots);
 
   if (mod_order0 == 4) {
     QAM_amp0_128  = _mm_set1_epi16(QAM16_n1);
@@ -1417,155 +1606,180 @@ void dlsch_channel_compensation_TM3(LTE_DL_FRAME_PARMS *frame_parms,
     
   for (aarx=0;aarx<frame_parms->nb_antennas_rx;aarx++) {
         
-    dl_ch0_128          = (__m128i *)&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*12];
-    dl_ch1_128          = (__m128i *)&dl_ch_estimates_ext[2+aarx][symbol*frame_parms->N_RB_DL*12];
-        
+   // printf("symbol %d, rx antenna %d\n", symbol, aarx);
+
+    dl_ch0_128          = (__m128i *)&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*12]; // this is h11
+    dl_ch1_128          = (__m128i *)&dl_ch_estimates_ext[2+aarx][symbol*frame_parms->N_RB_DL*12]; // this is h12
         
-    dl_ch_mag0_128      = (__m128i *)&dl_ch_mag0[aarx][symbol*frame_parms->N_RB_DL*12];
-    dl_ch_mag0_128b     = (__m128i *)&dl_ch_magb0[aarx][symbol*frame_parms->N_RB_DL*12];
-    dl_ch_mag1_128      = (__m128i *)&dl_ch_mag1[aarx][symbol*frame_parms->N_RB_DL*12];
-    dl_ch_mag1_128b     = (__m128i *)&dl_ch_magb1[aarx][symbol*frame_parms->N_RB_DL*12];
-    rxdataF128          = (__m128i *)&rxdataF_ext[aarx][symbol*frame_parms->N_RB_DL*12];
-    rxdataF_comp0_128   = (__m128i *)&rxdataF_comp0[aarx][symbol*frame_parms->N_RB_DL*12];
-    rxdataF_comp1_128   = (__m128i *)&rxdataF_comp1[aarx][symbol*frame_parms->N_RB_DL*12];
         
+    dl_ch_mag0_128      = (__m128i *)&dl_ch_mag0[aarx][symbol*frame_parms->N_RB_DL*12]; //responsible for x1
+    dl_ch_mag0_128b     = (__m128i *)&dl_ch_magb0[aarx][symbol*frame_parms->N_RB_DL*12];//responsible for x1
+    dl_ch_mag1_128      = (__m128i *)&dl_ch_mag1[aarx][symbol*frame_parms->N_RB_DL*12];   //responsible for x2. always coming from tx2
+    dl_ch_mag1_128b     = (__m128i *)&dl_ch_magb1[aarx][symbol*frame_parms->N_RB_DL*12];  //responsible for x2. always coming from tx2
+    rxdataF128         = (__m128i *)&rxdataF_ext[aarx][symbol*frame_parms->N_RB_DL*12]; //received signal on antenna of interest h11*x1+h12*x2
+    rxdataF_comp0_128   = (__m128i *)&rxdataF_comp0[aarx][symbol*frame_parms->N_RB_DL*12]; //result of multipl with MF x1 on antenna of interest
+    rxdataF_comp1_128   = (__m128i *)&rxdataF_comp1[aarx][symbol*frame_parms->N_RB_DL*12]; //result of multipl with MF x2 on antenna of interest
 
     for (rb=0;rb<nb_rb;rb++) {
       // combine TX channels using precoder from pmi
 
-      prec2A_TM3_128(&dl_ch0_128[0],&dl_ch1_128[0]);
-      prec2A_TM3_128(&dl_ch0_128[1],&dl_ch1_128[1]);
-
-      if (pilots==0) {
-	prec2A_TM3_128(&dl_ch0_128[2],&dl_ch1_128[2]); 
+      if (mimo_mode==LARGE_CDD) {
+        prec2A_TM3_128(&dl_ch0_128[0],&dl_ch1_128[0]);
+        prec2A_TM3_128(&dl_ch0_128[1],&dl_ch1_128[1]);
+        
+	
+        if (pilots==0) {
+          prec2A_TM3_128(&dl_ch0_128[2],&dl_ch1_128[2]); 
+        }
+      }
+      else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODING1) {
+        prec2A_TM4_128(0,&dl_ch0_128[0],&dl_ch1_128[0]); 
+        prec2A_TM4_128(0,&dl_ch0_128[1],&dl_ch1_128[1]); 
+        
+        if (pilots==0) {
+          prec2A_TM4_128(0,&dl_ch0_128[2],&dl_ch1_128[2]); 
+        }
+      }
+      else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODINGj) {
+        prec2A_TM4_128(1,&dl_ch0_128[0],&dl_ch1_128[0]);
+        prec2A_TM4_128(1,&dl_ch0_128[1],&dl_ch1_128[1]);
+        
+        if (pilots==0) {
+          prec2A_TM4_128(1,&dl_ch0_128[2],&dl_ch1_128[2]); 
+        }
+      }
+      else {
+        LOG_E(PHY,"Unknown MIMO mode\n");
+        return;
       }
+ 
 
       if (mod_order0>2) {  
-	// get channel amplitude if not QPSK
-	
-	mmtmpD0 = _mm_madd_epi16(dl_ch0_128[0],dl_ch0_128[0]);	
-	mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        // get channel amplitude if not QPSK
+        
+        mmtmpD0 = _mm_madd_epi16(dl_ch0_128[0],dl_ch0_128[0]);  
+        mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
                 
-	mmtmpD1 = _mm_madd_epi16(dl_ch0_128[1],dl_ch0_128[1]);
-	mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+        mmtmpD1 = _mm_madd_epi16(dl_ch0_128[1],dl_ch0_128[1]);
+        mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
                 
-	mmtmpD0 = _mm_packs_epi32(mmtmpD0,mmtmpD1);
+        mmtmpD0 = _mm_packs_epi32(mmtmpD0,mmtmpD1);
                 
-	dl_ch_mag0_128[0] = _mm_unpacklo_epi16(mmtmpD0,mmtmpD0);
-	dl_ch_mag0_128b[0] = dl_ch_mag0_128[0];
-	dl_ch_mag0_128[0] = _mm_mulhi_epi16(dl_ch_mag0_128[0],QAM_amp0_128);
-	dl_ch_mag0_128[0] = _mm_slli_epi16(dl_ch_mag0_128[0],1);
+        dl_ch_mag0_128[0] = _mm_unpacklo_epi16(mmtmpD0,mmtmpD0);
+        dl_ch_mag0_128b[0] = dl_ch_mag0_128[0];
+        dl_ch_mag0_128[0] = _mm_mulhi_epi16(dl_ch_mag0_128[0],QAM_amp0_128);
+        dl_ch_mag0_128[0] = _mm_slli_epi16(dl_ch_mag0_128[0],1);
                 
-	//	print_shorts("dl_ch_mag0_128[0]=",&dl_ch_mag0_128[0]);
+        //  print_shorts("dl_ch_mag0_128[0]=",&dl_ch_mag0_128[0]);
                 
-	dl_ch_mag0_128[1] = _mm_unpackhi_epi16(mmtmpD0,mmtmpD0);
-	dl_ch_mag0_128b[1] = dl_ch_mag0_128[1];
-	dl_ch_mag0_128[1] = _mm_mulhi_epi16(dl_ch_mag0_128[1],QAM_amp0_128);
-	dl_ch_mag0_128[1] = _mm_slli_epi16(dl_ch_mag0_128[1],1);
+        dl_ch_mag0_128[1] = _mm_unpackhi_epi16(mmtmpD0,mmtmpD0);
+        dl_ch_mag0_128b[1] = dl_ch_mag0_128[1];
+        dl_ch_mag0_128[1] = _mm_mulhi_epi16(dl_ch_mag0_128[1],QAM_amp0_128);
+        dl_ch_mag0_128[1] = _mm_slli_epi16(dl_ch_mag0_128[1],1);
                 
-	if (pilots==0) {
-	  mmtmpD0 = _mm_madd_epi16(dl_ch0_128[2],dl_ch0_128[2]);
-	  mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        if (pilots==0) {
+          mmtmpD0 = _mm_madd_epi16(dl_ch0_128[2],dl_ch0_128[2]);
+          mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
                     
-	  mmtmpD1 = _mm_packs_epi32(mmtmpD0,mmtmpD0);
+          mmtmpD1 = _mm_packs_epi32(mmtmpD0,mmtmpD0);
                     
-	  dl_ch_mag0_128[2] = _mm_unpacklo_epi16(mmtmpD1,mmtmpD1);
-	  dl_ch_mag0_128b[2] = dl_ch_mag0_128[2];
+          dl_ch_mag0_128[2] = _mm_unpacklo_epi16(mmtmpD1,mmtmpD1);
+          dl_ch_mag0_128b[2] = dl_ch_mag0_128[2];
                     
-	  dl_ch_mag0_128[2] = _mm_mulhi_epi16(dl_ch_mag0_128[2],QAM_amp0_128);
-	  dl_ch_mag0_128[2] = _mm_slli_epi16(dl_ch_mag0_128[2],1);	  
-	}
+          dl_ch_mag0_128[2] = _mm_mulhi_epi16(dl_ch_mag0_128[2],QAM_amp0_128);
+          dl_ch_mag0_128[2] = _mm_slli_epi16(dl_ch_mag0_128[2],1);        
+        }
                 
-	dl_ch_mag0_128b[0] = _mm_mulhi_epi16(dl_ch_mag0_128b[0],QAM_amp0_128b);
-	dl_ch_mag0_128b[0] = _mm_slli_epi16(dl_ch_mag0_128b[0],1);
+        dl_ch_mag0_128b[0] = _mm_mulhi_epi16(dl_ch_mag0_128b[0],QAM_amp0_128b);
+        dl_ch_mag0_128b[0] = _mm_slli_epi16(dl_ch_mag0_128b[0],1);
                 
-	//print_shorts("dl_ch_mag128b[0]=",&dl_ch_mag128b[0]);
+       // print_shorts("dl_ch_mag0_128b[0]=",&dl_ch_mag0_128b[0]);
                 
-	dl_ch_mag0_128b[1] = _mm_mulhi_epi16(dl_ch_mag0_128b[1],QAM_amp0_128b);
-	dl_ch_mag0_128b[1] = _mm_slli_epi16(dl_ch_mag0_128b[1],1);
+        dl_ch_mag0_128b[1] = _mm_mulhi_epi16(dl_ch_mag0_128b[1],QAM_amp0_128b);
+        dl_ch_mag0_128b[1] = _mm_slli_epi16(dl_ch_mag0_128b[1],1);
                 
-	if (pilots==0) {
-	  dl_ch_mag0_128b[2] = _mm_mulhi_epi16(dl_ch_mag0_128b[2],QAM_amp0_128b);
-	  dl_ch_mag0_128b[2] = _mm_slli_epi16(dl_ch_mag0_128b[2],1);	  
-	}
+        if (pilots==0) {
+          dl_ch_mag0_128b[2] = _mm_mulhi_epi16(dl_ch_mag0_128b[2],QAM_amp0_128b);
+          dl_ch_mag0_128b[2] = _mm_slli_epi16(dl_ch_mag0_128b[2],1);      
+        }
       }
 
       if (mod_order1>2) {  
-	// get channel amplitude if not QPSK
-	
-	mmtmpD0 = _mm_madd_epi16(dl_ch1_128[0],dl_ch1_128[0]);	
-	mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        // get channel amplitude if not QPSK
+        
+        mmtmpD0 = _mm_madd_epi16(dl_ch1_128[0],dl_ch1_128[0]);  
+        mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
                 
-	mmtmpD1 = _mm_madd_epi16(dl_ch1_128[1],dl_ch1_128[1]);
-	mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+        mmtmpD1 = _mm_madd_epi16(dl_ch1_128[1],dl_ch1_128[1]);
+        mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
                 
-	mmtmpD0 = _mm_packs_epi32(mmtmpD0,mmtmpD1);
+        mmtmpD0 = _mm_packs_epi32(mmtmpD0,mmtmpD1);
                 
-	dl_ch_mag1_128[0] = _mm_unpacklo_epi16(mmtmpD0,mmtmpD0);
-	dl_ch_mag1_128b[0] = dl_ch_mag1_128[0];
-	dl_ch_mag1_128[0] = _mm_mulhi_epi16(dl_ch_mag1_128[0],QAM_amp1_128);
-	dl_ch_mag1_128[0] = _mm_slli_epi16(dl_ch_mag1_128[0],1);
+        dl_ch_mag1_128[0] = _mm_unpacklo_epi16(mmtmpD0,mmtmpD0);
+        dl_ch_mag1_128b[0] = dl_ch_mag1_128[0];
+        dl_ch_mag1_128[0] = _mm_mulhi_epi16(dl_ch_mag1_128[0],QAM_amp1_128);
+        dl_ch_mag1_128[0] = _mm_slli_epi16(dl_ch_mag1_128[0],1);
                 
-	//print_shorts("dl_ch_mag128[0]=",&dl_ch_mag128[0]);
+       // print_shorts("dl_ch_mag1_128[0]=",&dl_ch_mag1_128[0]);
                 
-	dl_ch_mag1_128[1] = _mm_unpackhi_epi16(mmtmpD0,mmtmpD0);
-	dl_ch_mag1_128b[1] = dl_ch_mag1_128[1];
-	dl_ch_mag1_128[1] = _mm_mulhi_epi16(dl_ch_mag1_128[1],QAM_amp1_128);
-	dl_ch_mag1_128[1] = _mm_slli_epi16(dl_ch_mag1_128[1],1);
+        dl_ch_mag1_128[1] = _mm_unpackhi_epi16(mmtmpD0,mmtmpD0);
+        dl_ch_mag1_128b[1] = dl_ch_mag1_128[1];
+        dl_ch_mag1_128[1] = _mm_mulhi_epi16(dl_ch_mag1_128[1],QAM_amp1_128);
+        dl_ch_mag1_128[1] = _mm_slli_epi16(dl_ch_mag1_128[1],1);
                 
-	if (pilots==0) {
-	  mmtmpD0 = _mm_madd_epi16(dl_ch1_128[2],dl_ch1_128[2]);
-	  mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        if (pilots==0) {
+          mmtmpD0 = _mm_madd_epi16(dl_ch1_128[2],dl_ch1_128[2]);
+          mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
                     
-	  mmtmpD1 = _mm_packs_epi32(mmtmpD0,mmtmpD0);
+          mmtmpD1 = _mm_packs_epi32(mmtmpD0,mmtmpD0);
                     
-	  dl_ch_mag1_128[2] = _mm_unpacklo_epi16(mmtmpD1,mmtmpD1);
-	  dl_ch_mag1_128b[2] = dl_ch_mag1_128[2];
+          dl_ch_mag1_128[2] = _mm_unpacklo_epi16(mmtmpD1,mmtmpD1);
+          dl_ch_mag1_128b[2] = dl_ch_mag1_128[2];
                     
-	  dl_ch_mag1_128[2] = _mm_mulhi_epi16(dl_ch_mag1_128[2],QAM_amp1_128);
-	  dl_ch_mag1_128[2] = _mm_slli_epi16(dl_ch_mag1_128[2],1);	  
-	}
+          dl_ch_mag1_128[2] = _mm_mulhi_epi16(dl_ch_mag1_128[2],QAM_amp1_128);
+          dl_ch_mag1_128[2] = _mm_slli_epi16(dl_ch_mag1_128[2],1);        
+        }
                 
-	dl_ch_mag1_128b[0] = _mm_mulhi_epi16(dl_ch_mag1_128b[0],QAM_amp1_128b);
-	dl_ch_mag1_128b[0] = _mm_slli_epi16(dl_ch_mag1_128b[0],1);
+        dl_ch_mag1_128b[0] = _mm_mulhi_epi16(dl_ch_mag1_128b[0],QAM_amp1_128b);
+        dl_ch_mag1_128b[0] = _mm_slli_epi16(dl_ch_mag1_128b[0],1);
                 
-	//print_shorts("dl_ch_mag128b[0]=",&dl_ch_mag128b[0]);
+       // print_shorts("dl_ch_mag1_128b[0]=",&dl_ch_mag1_128b[0]);
                 
-	dl_ch_mag1_128b[1] = _mm_mulhi_epi16(dl_ch_mag1_128b[1],QAM_amp1_128b);
-	dl_ch_mag1_128b[1] = _mm_slli_epi16(dl_ch_mag1_128b[1],1);
+        dl_ch_mag1_128b[1] = _mm_mulhi_epi16(dl_ch_mag1_128b[1],QAM_amp1_128b);
+        dl_ch_mag1_128b[1] = _mm_slli_epi16(dl_ch_mag1_128b[1],1);
                 
-	if (pilots==0) {
-	  dl_ch_mag1_128b[2] = _mm_mulhi_epi16(dl_ch_mag1_128b[2],QAM_amp1_128b);
-	  dl_ch_mag1_128b[2] = _mm_slli_epi16(dl_ch_mag1_128b[2],1);	  
-	}
+        if (pilots==0) {
+          dl_ch_mag1_128b[2] = _mm_mulhi_epi16(dl_ch_mag1_128b[2],QAM_amp1_128b);
+          dl_ch_mag1_128b[2] = _mm_slli_epi16(dl_ch_mag1_128b[2],1);      
+        }
       }
 
-      // layer 0
+      // layer 0 
       // MF multiply by conjugated channel
       mmtmpD0 = _mm_madd_epi16(dl_ch0_128[0],rxdataF128[0]);
-      //print_ints("re",&mmtmpD0);
+    //  print_ints("re",&mmtmpD0); 
             
       // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
       mmtmpD1 = _mm_shufflelo_epi16(dl_ch0_128[0],_MM_SHUFFLE(2,3,0,1));
       mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
       mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)&conjugate[0]);
       mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[0]);
-      //      print_ints("im",&mmtmpD1);
+           // print_ints("im",&mmtmpD1);
       // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
       mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-      //      printf("Shift: %d\n",output_shift);
-      //      print_ints("re(shift)",&mmtmpD0);
+           // printf("Shift: %d\n",output_shift);
+          // print_ints("re(shift)",&mmtmpD0);
       mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
-      //      print_ints("im(shift)",&mmtmpD1);
+           // print_ints("im(shift)",&mmtmpD1);
       mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
       mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
-      //      print_ints("c0",&mmtmpD2);
-      //      print_ints("c1",&mmtmpD3);
+          //  print_ints("c0",&mmtmpD2);
+          // print_ints("c1",&mmtmpD3);
       rxdataF_comp0_128[0] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
-      //      print_shorts("rx:",rxdataF128);
-      //      print_shorts("ch:",dl_ch0_128);
-      //      print_shorts("pack:",rxdataF_comp0_128);
-            
+           // print_shorts("rx:",rxdataF128);
+           // print_shorts("ch:",dl_ch0_128);
+        // print_shorts("pack:",rxdataF_comp0_128);
+          
       // multiply by conjugated channel
       mmtmpD0 = _mm_madd_epi16(dl_ch0_128[1],rxdataF128[1]);
       // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
@@ -1580,59 +1794,58 @@ void dlsch_channel_compensation_TM3(LTE_DL_FRAME_PARMS *frame_parms,
       mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
             
       rxdataF_comp0_128[1] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
-      //	print_shorts("rx:",rxdataF128+1);
-      //	print_shorts("ch:",dl_ch128+1);
-      //	print_shorts("pack:",rxdataF_comp128+1);	
+           //  print_shorts("rx:",rxdataF128+1);
+            //  print_shorts("ch:",dl_ch0_128+1);
+            // print_shorts("pack:",rxdataF_comp0_128+1);        
             
       if (pilots==0) {
-	// multiply by conjugated channel
-	mmtmpD0 = _mm_madd_epi16(dl_ch0_128[2],rxdataF128[2]);
-	// mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
-	mmtmpD1 = _mm_shufflelo_epi16(dl_ch0_128[2],_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
-	mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[2]);
-	// mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
-	mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-	mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
-	mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
-	mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+        // multiply by conjugated channel
+        mmtmpD0 = _mm_madd_epi16(dl_ch0_128[2],rxdataF128[2]);
+        // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+        mmtmpD1 = _mm_shufflelo_epi16(dl_ch0_128[2],_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
+        mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[2]);
+        // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+        mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+        mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+        mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
                 
-	rxdataF_comp0_128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
-	//	print_shorts("rx:",rxdataF128+2);
-	//	print_shorts("ch:",dl_ch128+2);
-	//      	print_shorts("pack:",rxdataF_comp128+2);
+        rxdataF_comp0_128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
+           //   print_shorts("rx:",rxdataF128+2);
+           //   print_shorts("ch:",dl_ch0_128+2);
+            //  print_shorts("pack:",rxdataF_comp0_128+2);
+	
+	
                 
       }
-      else {
-
-      }
       
       
       // layer 1
       // MF multiply by conjugated channel
       mmtmpD0 = _mm_madd_epi16(dl_ch1_128[0],rxdataF128[0]);
-      //	print_ints("re",&mmtmpD0);
+           //  print_ints("re",&mmtmpD0);
       
       // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
       mmtmpD1 = _mm_shufflelo_epi16(dl_ch1_128[0],_MM_SHUFFLE(2,3,0,1));
       mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
       mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)&conjugate[0]);
-      //	print_ints("im",&mmtmpD1);
+            //  print_ints("im",&mmtmpD1);
       mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[0]);
       // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
       mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-      //	print_ints("re(shift)",&mmtmpD0);
+             // print_ints("re(shift)",&mmtmpD0);
       mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
-      //	print_ints("im(shift)",&mmtmpD1);
+             // print_ints("im(shift)",&mmtmpD1);
       mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
       mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
-      //       	print_ints("c0",&mmtmpD2);
-      //	print_ints("c1",&mmtmpD3);
+             // print_ints("c0",&mmtmpD2);
+             // print_ints("c1",&mmtmpD3);
       rxdataF_comp1_128[0] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
-      //	print_shorts("rx:",rxdataF128);
-      //	print_shorts("ch:",dl_ch128);
-      //	print_shorts("pack:",rxdataF_comp128);
+            // print_shorts("rx:",rxdataF128);
+            //  print_shorts("ch:",dl_ch1_128);
+            // print_shorts("pack:",rxdataF_comp1_128);
       
       // multiply by conjugated channel
       mmtmpD0 = _mm_madd_epi16(dl_ch1_128[1],rxdataF128[1]);
@@ -1648,71 +1861,73 @@ void dlsch_channel_compensation_TM3(LTE_DL_FRAME_PARMS *frame_parms,
       mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
       
       rxdataF_comp1_128[1] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
-      //	print_shorts("rx:",rxdataF128+1);
-      //	print_shorts("ch:",dl_ch128+1);
-      //	print_shorts("pack:",rxdataF_comp128+1);	
+            //  print_shorts("rx:",rxdataF128+1);
+           // print_shorts("ch:",dl_ch1_128+1);
+            // print_shorts("pack:",rxdataF_comp1_128+1);        
       
       if (pilots==0) {
-	// multiply by conjugated channel
-	mmtmpD0 = _mm_madd_epi16(dl_ch1_128[2],rxdataF128[2]);
-	// mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
-	mmtmpD1 = _mm_shufflelo_epi16(dl_ch1_128[2],_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
-	mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[2]);
-	// mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
-	mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-	mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
-	mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
-	mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
-	
-	rxdataF_comp1_128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
-	//	print_shorts("rx:",rxdataF128+2);
-	//	print_shorts("ch:",dl_ch128+2);
-	//      	print_shorts("pack:",rxdataF_comp128+2);
-	
-	dl_ch0_128+=3;
-	dl_ch1_128+=3;
-	dl_ch_mag0_128+=3;
-	dl_ch_mag1_128+=3;
-	dl_ch_mag0_128b+=3;
-	dl_ch_mag1_128b+=3;
-	rxdataF128+=3;
-	rxdataF_comp0_128+=3;
-	rxdataF_comp1_128+=3;
+        // multiply by conjugated channel
+        mmtmpD0 = _mm_madd_epi16(dl_ch1_128[2],rxdataF128[2]);
+        // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+        mmtmpD1 = _mm_shufflelo_epi16(dl_ch1_128[2],_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
+        mmtmpD1 = _mm_madd_epi16(mmtmpD1,rxdataF128[2]);
+        // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+        mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+        mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+        mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+        
+        rxdataF_comp1_128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
+          //   print_shorts("rx:",rxdataF128+2);
+           //  print_shorts("ch:",dl_ch1_128+2);
+             //         print_shorts("pack:",rxdataF_comp1_128+2);
+        
+        dl_ch0_128+=3;
+        dl_ch1_128+=3;
+        dl_ch_mag0_128+=3;
+        dl_ch_mag1_128+=3;
+        dl_ch_mag0_128b+=3;
+        dl_ch_mag1_128b+=3;
+        rxdataF128+=3;
+        rxdataF_comp0_128+=3;
+        rxdataF_comp1_128+=3;
       }
       else {
-	dl_ch0_128+=2;
-	dl_ch1_128+=2;
-	dl_ch_mag0_128+=2;
-	dl_ch_mag1_128+=2;
-	dl_ch_mag0_128b+=2;
-	dl_ch_mag1_128b+=2;
-	rxdataF128+=2;
-	rxdataF_comp0_128+=2;
-	rxdataF_comp1_128+=2;
+        dl_ch0_128+=2;
+        dl_ch1_128+=2;
+        dl_ch_mag0_128+=2;
+        dl_ch_mag1_128+=2;
+        dl_ch_mag0_128b+=2;
+        dl_ch_mag1_128b+=2;
+        rxdataF128+=2;
+        rxdataF_comp0_128+=2;
+        rxdataF_comp1_128+=2;
       }
       
-      Nre = (pilots==0) ? 12 : 8;
+    } // rb loop
+    Nre = (pilots==0) ? 12 : 8;
       
-      precoded_signal_strength0 += ((signal_energy_nodc(&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*Nre],
-							(nb_rb*Nre))*rx_power_correction) - (phy_measurements->n0_power[aarx]));
+    precoded_signal_strength0 += ((signal_energy_nodc(&dl_ch_estimates_ext[aarx][symbol*frame_parms->N_RB_DL*Nre],
+                                                        (nb_rb*Nre))*rx_power_correction) - (phy_measurements->n0_power[aarx]));
       
-      precoded_signal_strength1 += ((signal_energy_nodc(&dl_ch_estimates_ext[aarx+2][symbol*frame_parms->N_RB_DL*Nre],
-							(nb_rb*Nre))*rx_power_correction) - (phy_measurements->n0_power[aarx]));
-    } // rb loop
+    precoded_signal_strength1 += ((signal_energy_nodc(&dl_ch_estimates_ext[aarx+2][symbol*frame_parms->N_RB_DL*Nre],
+                                                        (nb_rb*Nre))*rx_power_correction) - (phy_measurements->n0_power[aarx]));
   } // rx_antennas
       
   phy_measurements->precoded_cqi_dB[eNB_id][0] = dB_fixed2(precoded_signal_strength0,phy_measurements->n0_power_tot);
   phy_measurements->precoded_cqi_dB[eNB_id][1] = dB_fixed2(precoded_signal_strength1,phy_measurements->n0_power_tot);
-	
-  //printf("eNB_id %d, symbol %d: precoded CQI %d dB\n",eNB_id,symbol,
-  //	 phy_measurements->precoded_cqi_dB[eNB_id][0]);
+        
+ // printf("eNB_id %d, symbol %d: precoded CQI %d dB\n",eNB_id,symbol,
+     //  phy_measurements->precoded_cqi_dB[eNB_id][0]);
     
   _mm_empty();
   _m_empty();  
 }     
 
+
+
 void dlsch_dual_stream_correlation(LTE_DL_FRAME_PARMS *frame_parms,
                                    unsigned char symbol,
                                    unsigned short nb_rb,
@@ -1780,30 +1995,30 @@ void dlsch_dual_stream_correlation(LTE_DL_FRAME_PARMS *frame_parms,
       dl_ch_rho128[1] =_mm_packs_epi32(mmtmpD2,mmtmpD3);
             
       if (pilots==0) {  
-	// multiply by conjugated channel
-	mmtmpD0 = _mm_madd_epi16(dl_ch128[2],dl_ch128i[2]);
-	// mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
-	mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[2],_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
-	mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
-	mmtmpD1 = _mm_madd_epi16(mmtmpD1,dl_ch128i[2]);
-	// mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
-	mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
-	mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
-	mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
-	mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
-	dl_ch_rho128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
+        // multiply by conjugated channel
+        mmtmpD0 = _mm_madd_epi16(dl_ch128[2],dl_ch128i[2]);
+        // mmtmpD0 contains real part of 4 consecutive outputs (32-bit)
+        mmtmpD1 = _mm_shufflelo_epi16(dl_ch128[2],_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_shufflehi_epi16(mmtmpD1,_MM_SHUFFLE(2,3,0,1));
+        mmtmpD1 = _mm_sign_epi16(mmtmpD1,*(__m128i*)conjugate);
+        mmtmpD1 = _mm_madd_epi16(mmtmpD1,dl_ch128i[2]);
+        // mmtmpD1 contains imag part of 4 consecutive outputs (32-bit)
+        mmtmpD0 = _mm_srai_epi32(mmtmpD0,output_shift);
+        mmtmpD1 = _mm_srai_epi32(mmtmpD1,output_shift);
+        mmtmpD2 = _mm_unpacklo_epi32(mmtmpD0,mmtmpD1);
+        mmtmpD3 = _mm_unpackhi_epi32(mmtmpD0,mmtmpD1);
+        dl_ch_rho128[2] = _mm_packs_epi32(mmtmpD2,mmtmpD3);
                 
-	dl_ch128+=3;
-	dl_ch128i+=3;
-	dl_ch_rho128+=3;
+        dl_ch128+=3;
+        dl_ch128i+=3;
+        dl_ch_rho128+=3;
       }
       else {      
-	dl_ch128+=2;
-	dl_ch128i+=2;
-	dl_ch_rho128+=2;
+        dl_ch128+=2;
+        dl_ch128i+=2;
+        dl_ch_rho128+=2;
       }
-    }	        
+    }           
   }
   
   _mm_empty();
@@ -1840,9 +2055,14 @@ void dlsch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms,
 
       // MRC on each re of rb, both on MF output and magnitude (for 16QAM/64QAM llr computation)
       for (i=0;i<nb_rb*3;i++) {
-	rxdataF_comp128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_0[i],1),_mm_srai_epi16(rxdataF_comp128_1[i],1));
-	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));
+        rxdataF_comp128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_0[i],1),_mm_srai_epi16(rxdataF_comp128_1[i],1));
+        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 rho1:",&rho128_1[i]);
+	
       }
     }
 
@@ -1850,9 +2070,9 @@ void dlsch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms,
       rho128_0 = (__m128i *) &rho[0][symbol*frame_parms->N_RB_DL*12];
       rho128_1 = (__m128i *) &rho[1][symbol*frame_parms->N_RB_DL*12];
       for (i=0;i<nb_rb*3;i++) {
-	//	print_shorts("mrc rho0:",&rho128_0[i]);
-	//	print_shorts("mrc rho1:",&rho128_1[i]);
-	rho128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rho128_0[i],1),_mm_srai_epi16(rho128_1[i],1));
+        //      print_shorts("mrc rho0:",&rho128_0[i]);
+        //      print_shorts("mrc rho1:",&rho128_1[i]);
+        rho128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rho128_0[i],1),_mm_srai_epi16(rho128_1[i],1));
       }
     }
 
@@ -1867,11 +2087,11 @@ void dlsch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms,
       dl_ch_mag128_i0b     = (__m128i *)&dl_ch_magb_i[0][symbol*frame_parms->N_RB_DL*12];  
       dl_ch_mag128_i1b     = (__m128i *)&dl_ch_magb_i[1][symbol*frame_parms->N_RB_DL*12];
       for (i=0;i<nb_rb*3;i++) {
-	rxdataF_comp128_i0[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_i0[i],1),_mm_srai_epi16(rxdataF_comp128_i1[i],1));
-	rho128_i0[i]           = _mm_adds_epi16(_mm_srai_epi16(rho128_i0[i],1),_mm_srai_epi16(rho128_i1[i],1));
+        rxdataF_comp128_i0[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_i0[i],1),_mm_srai_epi16(rxdataF_comp128_i1[i],1));
+        rho128_i0[i]           = _mm_adds_epi16(_mm_srai_epi16(rho128_i0[i],1),_mm_srai_epi16(rho128_i1[i],1));
             
-	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));
+        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));
       }
     }
   }
@@ -1879,6 +2099,92 @@ void dlsch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms,
   _m_empty();
 }
 
+
+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) {
+    
+  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];
+  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;
+  int **dl_ch_magb0           	= lte_ue_pdsch_vars->dl_ch_magb0;
+  int **dl_ch_magb1           	= lte_ue_pdsch_vars->dl_ch_magb1;
+  
+  
+  if (frame_parms->nb_antennas_rx>1) {
+      
+    for (aatx=0;aatx<frame_parms->nb_antennas_tx_eNB;aatx++) {
+
+      rxdataF_comp128_0   = (__m128i *)&rxdataF_comp0[(aatx<<1)][symbol*frame_parms->N_RB_DL*12];  
+      rxdataF_comp128_1   = (__m128i *)&rxdataF_comp0[(aatx<<1)+1][symbol*frame_parms->N_RB_DL*12];  
+      dl_ch_mag128_0      = (__m128i *)&dl_ch_mag0[(aatx<<1)][symbol*frame_parms->N_RB_DL*12];  
+      dl_ch_mag128_1      = (__m128i *)&dl_ch_mag0[(aatx<<1)+1][symbol*frame_parms->N_RB_DL*12];  
+      dl_ch_mag128_0b     = (__m128i *)&dl_ch_magb0[(aatx<<1)][symbol*frame_parms->N_RB_DL*12];  
+      dl_ch_mag128_1b     = (__m128i *)&dl_ch_magb0[(aatx<<1)+1][symbol*frame_parms->N_RB_DL*12];  
+
+      // MRC on each re of rb, both on MF output and magnitude (for 16QAM/64QAM llr computation)
+      for (i=0;i<nb_rb*3;i++) {
+        rxdataF_comp128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_0[i],1),_mm_srai_epi16(rxdataF_comp128_1[i],1));
+        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]);
+      }
+    }
+
+   // if (rho) {
+      rho128_0 = (__m128i *) &dl_ch_rho_ext[0][symbol*frame_parms->N_RB_DL*12];
+      rho128_1 = (__m128i *) &dl_ch_rho_ext[1][symbol*frame_parms->N_RB_DL*12];
+      for (i=0;i<nb_rb*3;i++) {
+           //  print_shorts("mrc rho0:",&rho128_0[i]);
+            //  print_shorts("mrc rho1:",&rho128_1[i]);
+        rho128_0[i] = _mm_adds_epi16(_mm_srai_epi16(rho128_0[i],1),_mm_srai_epi16(rho128_1[i],1));
+      }
+   //}
+
+
+    if (dual_stream_UE == 1) {
+      rho128_i0 = (__m128i *) &dl_ch_rho2_ext[0][symbol*frame_parms->N_RB_DL*12];
+      rho128_i1 = (__m128i *) &dl_ch_rho2_ext[1][symbol*frame_parms->N_RB_DL*12];
+      rxdataF_comp128_i0   = (__m128i *)&rxdataF_comp1[0][symbol*frame_parms->N_RB_DL*12];  
+      rxdataF_comp128_i1   = (__m128i *)&rxdataF_comp1[1][symbol*frame_parms->N_RB_DL*12];  
+      dl_ch_mag128_i0      = (__m128i *)&dl_ch_mag1[0][symbol*frame_parms->N_RB_DL*12];  
+      dl_ch_mag128_i1      = (__m128i *)&dl_ch_mag1[1][symbol*frame_parms->N_RB_DL*12]; 
+      dl_ch_mag128_i0b     = (__m128i *)&dl_ch_magb1[0][symbol*frame_parms->N_RB_DL*12];  
+      dl_ch_mag128_i1b     = (__m128i *)&dl_ch_magb1[1][symbol*frame_parms->N_RB_DL*12];
+      for (i=0;i<nb_rb*3;i++) {
+        rxdataF_comp128_i0[i] = _mm_adds_epi16(_mm_srai_epi16(rxdataF_comp128_i0[i],1),_mm_srai_epi16(rxdataF_comp128_i1[i],1));
+        rho128_i0[i]           = _mm_adds_epi16(_mm_srai_epi16(rho128_i0[i],1),_mm_srai_epi16(rho128_i1[i],1));
+            
+        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]);
+      }
+    }
+  }
+
+  _mm_empty();
+  _m_empty();
+}
+
+
+
 void dlsch_scale_channel(int **dl_ch_estimates_ext,
                          LTE_DL_FRAME_PARMS *frame_parms,
                          LTE_UE_DLSCH_t **dlsch_ue,
@@ -1899,42 +2205,43 @@ void dlsch_scale_channel(int **dl_ch_estimates_ext,
   }
 
   // Determine scaling amplitude based the symbol
-  ch_amp = ((pilots) ? (dlsch_ue[0]->sqrt_rho_b) : (dlsch_ue[0]->sqrt_rho_a));
+  
+ch_amp = ((pilots) ? (dlsch_ue[0]->sqrt_rho_b) : (dlsch_ue[0]->sqrt_rho_a));
 
-  //  LOG_D(PHY,"Scaling PDSCH Chest in OFDM symbol %d by %d\n",symbol_mod,ch_amp);
+    LOG_D(PHY,"Scaling PDSCH Chest in OFDM symbol %d by %d\n",symbol_mod,ch_amp);
 
   ch_amp128 = _mm_set1_epi16(ch_amp); // Q3.13
-
-  for (aatx=0;aatx<frame_parms->nb_antennas_tx_eNB;aatx++) {
+ for (aatx=0;aatx<frame_parms->nb_antennas_tx_eNB;aatx++) {
     for (aarx=0;aarx<frame_parms->nb_antennas_rx;aarx++) {
 
       dl_ch128=(__m128i *)&dl_ch_estimates_ext[(aatx<<1)+aarx][symbol*frame_parms->N_RB_DL*12];
                 
       for (rb=0;rb<nb_rb;rb++) {
-	dl_ch128[0] = _mm_mulhi_epi16(dl_ch128[0],ch_amp128);
-	dl_ch128[0] = _mm_slli_epi16(dl_ch128[0],3);
-
-	dl_ch128[1] = _mm_mulhi_epi16(dl_ch128[1],ch_amp128);
-	dl_ch128[1] = _mm_slli_epi16(dl_ch128[1],3);
-
-	if (pilots) {
-	  dl_ch128+=2;
-	} else {
-	  dl_ch128[2] = _mm_mulhi_epi16(dl_ch128[2],ch_amp128);
-	  dl_ch128[2] = _mm_slli_epi16(dl_ch128[2],3);
-	  dl_ch128+=3;
-	}	
+        dl_ch128[0] = _mm_mulhi_epi16(dl_ch128[0],ch_amp128);
+        dl_ch128[0] = _mm_slli_epi16(dl_ch128[0],3);
+
+        dl_ch128[1] = _mm_mulhi_epi16(dl_ch128[1],ch_amp128);
+        dl_ch128[1] = _mm_slli_epi16(dl_ch128[1],3);
+
+        if (pilots) {
+          dl_ch128+=2;
+        } else {
+          dl_ch128[2] = _mm_mulhi_epi16(dl_ch128[2],ch_amp128);
+          dl_ch128[2] = _mm_slli_epi16(dl_ch128[2],3);
+          dl_ch128+=3;
+        }       
       }                
     }
   }
 }
 
+
 //compute average channel_level on each (TX,RX) antenna pair
 void dlsch_channel_level(int **dl_ch_estimates_ext,
-			 LTE_DL_FRAME_PARMS *frame_parms,
-			 int *avg,
-			 uint8_t symbol,
-			 unsigned short nb_rb){
+                         LTE_DL_FRAME_PARMS *frame_parms,
+                         int *avg,
+                         uint8_t symbol,
+                         unsigned short nb_rb){
 
   short rb;
   unsigned char aatx,aarx,nre=12,symbol_mod;
@@ -1951,37 +2258,37 @@ void dlsch_channel_level(int **dl_ch_estimates_ext,
       dl_ch128=(__m128i *)&dl_ch_estimates_ext[(aatx<<1)+aarx][symbol*frame_parms->N_RB_DL*12];
 
       for (rb=0;rb<nb_rb;rb++) {
-	//	printf("rb %d : ",rb);
-	//	print_shorts("ch",&dl_ch128[0]);
-	avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch128[0],dl_ch128[0]));
-	avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch128[1],dl_ch128[1]));
-	if (((symbol_mod == 0) || (symbol_mod == (frame_parms->Ncp-1)))&&(frame_parms->mode1_flag==0)) {
-	  dl_ch128+=2;	
-	}
-	else {
-	  avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch128[2],dl_ch128[2]));
-	  dl_ch128+=3;	
-	}
-	/*
-	  if (rb==0) {
-	  print_shorts("dl_ch128",&dl_ch128[0]);
-	  print_shorts("dl_ch128",&dl_ch128[1]);
-	  print_shorts("dl_ch128",&dl_ch128[2]);
-	  }
-	*/
+        //      printf("rb %d : ",rb);
+        //      print_shorts("ch",&dl_ch128[0]);
+        avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch128[0],dl_ch128[0]));
+        avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch128[1],dl_ch128[1]));
+        if (((symbol_mod == 0) || (symbol_mod == (frame_parms->Ncp-1)))&&(frame_parms->mode1_flag==0)) {
+          dl_ch128+=2;  
+        }
+        else {
+          avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch128[2],dl_ch128[2]));
+          dl_ch128+=3;  
+        }
+        /*
+          if (rb==0) {
+          print_shorts("dl_ch128",&dl_ch128[0]);
+          print_shorts("dl_ch128",&dl_ch128[1]);
+          print_shorts("dl_ch128",&dl_ch128[2]);
+          }
+        */
       }
 
       if (((symbol_mod == 0) || (symbol_mod == (frame_parms->Ncp-1)))&&(frame_parms->mode1_flag==0))
-	nre=8;
+        nre=8;
       else if (((symbol_mod == 0) || (symbol_mod == (frame_parms->Ncp-1)))&&(frame_parms->mode1_flag==1))
-	nre=10;
+        nre=10;
       else
-	nre=12;
+        nre=12;
 
       avg[(aatx<<1)+aarx] = (((int*)&avg128D)[0] + 
-			     ((int*)&avg128D)[1] + 
-			     ((int*)&avg128D)[2] + 
-			     ((int*)&avg128D)[3])/(nb_rb*nre);
+                             ((int*)&avg128D)[1] + 
+                             ((int*)&avg128D)[2] + 
+                             ((int*)&avg128D)[3])/(nb_rb*nre);
 
       //            printf("Channel level : %d\n",avg[(aatx<<1)+aarx]);
     }
@@ -1991,11 +2298,12 @@ void dlsch_channel_level(int **dl_ch_estimates_ext,
 }
 
 //compute average channel_level of effective (precoded) channel
-void dlsch_channel_level_TM3(int **dl_ch_estimates_ext,
-			     LTE_DL_FRAME_PARMS *frame_parms,
-			     int *avg,
-			     uint8_t symbol,
-			     unsigned short nb_rb){
+void dlsch_channel_level_TM34(int **dl_ch_estimates_ext,
+                              LTE_DL_FRAME_PARMS *frame_parms,
+                              int *avg,
+                              uint8_t symbol,
+                              unsigned short nb_rb,
+                              MIMO_mode_t mimo_mode){
 
   short rb;
   unsigned char aarx,nre=12,symbol_mod;
@@ -2025,31 +2333,49 @@ void dlsch_channel_level_TM3(int **dl_ch_estimates_ext,
       dl_ch0_128_tmp = _mm_load_si128(&dl_ch0_128[0]);
       dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[0]);
 
-      prec2A_TM3_128(&dl_ch0_128_tmp,&dl_ch1_128_tmp);
+      if (mimo_mode==LARGE_CDD) 
+        prec2A_TM3_128(&dl_ch0_128_tmp,&dl_ch1_128_tmp);
+      else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODING1)
+        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);
+
       //      mmtmpD0 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);          
       avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
 
       dl_ch0_128_tmp = _mm_load_si128(&dl_ch0_128[1]);
       dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[1]);          
 
-      prec2A_TM3_128(&dl_ch0_128_tmp,&dl_ch1_128_tmp);
+      if (mimo_mode==LARGE_CDD) 
+        prec2A_TM3_128(&dl_ch0_128_tmp,&dl_ch1_128_tmp);
+      else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODING1)
+        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);
+
       //      mmtmpD1 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);          
       avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
 
       if (((symbol_mod == 0) || (symbol_mod == (frame_parms->Ncp-1)))&&(frame_parms->mode1_flag==0)) {
-	dl_ch0_128+=2;	
-	dl_ch1_128+=2;
+        dl_ch0_128+=2;  
+        dl_ch1_128+=2;
       }
       else {
-	dl_ch0_128_tmp = _mm_load_si128(&dl_ch0_128[2]);
-	dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[2]);          
+        dl_ch0_128_tmp = _mm_load_si128(&dl_ch0_128[2]);
+        dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[2]);          
+
+        if (mimo_mode==LARGE_CDD) 
+          prec2A_TM3_128(&dl_ch0_128_tmp,&dl_ch1_128_tmp);
+        else if (mimo_mode==DUALSTREAM_UNIFORM_PRECODING1)
+          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);
 
-	prec2A_TM3_128(&dl_ch0_128_tmp,&dl_ch1_128_tmp);
-	//	mmtmpD2 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);
-	avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
+        //      mmtmpD2 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);
+        avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
 
-	dl_ch0_128+=3;	
-	dl_ch1_128+=3;
+        dl_ch0_128+=3;  
+        dl_ch1_128+=3;
       }          
     }
     avg[aarx] = (((int*)&avg128D)[0])/(nb_rb*nre) + 
@@ -2112,19 +2438,19 @@ void dlsch_channel_level_TM56(int **dl_ch_estimates_ext,
       avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
 
       if (((symbol_mod == 0) || (symbol_mod == (frame_parms->Ncp-1)))&&(frame_parms->mode1_flag==0)) {
-	dl_ch0_128+=2;	
-	dl_ch1_128+=2;
+        dl_ch0_128+=2;  
+        dl_ch1_128+=2;
       }
       else {
-	dl_ch0_128_tmp = _mm_load_si128(&dl_ch0_128[2]);
-	dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[2]);          
+        dl_ch0_128_tmp = _mm_load_si128(&dl_ch0_128[2]);
+        dl_ch1_128_tmp = _mm_load_si128(&dl_ch1_128[2]);          
 
-	prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128_tmp,&dl_ch1_128_tmp);
-	//	mmtmpD2 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);
-	avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
+        prec2A_TM56_128(pmi_ext[rb],&dl_ch0_128_tmp,&dl_ch1_128_tmp);
+        //      mmtmpD2 = _mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp);
+        avg128D = _mm_add_epi32(avg128D,_mm_madd_epi16(dl_ch0_128_tmp,dl_ch0_128_tmp));
 
-	dl_ch0_128+=3;	
-	dl_ch1_128+=3;
+        dl_ch0_128+=3;  
+        dl_ch1_128+=3;
       }          
     }
     avg[aarx] = (((int*)&avg128D)[0])/(nb_rb*nre) + 
@@ -2264,7 +2590,7 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
                                         unsigned int *rb_alloc,
                                         unsigned char symbol,
                                         unsigned char subframe,
-					uint32_t high_speed_flag,
+                                        uint32_t high_speed_flag,
                                         LTE_DL_FRAME_PARMS *frame_parms) {
 
 
@@ -2307,420 +2633,420 @@ unsigned short dlsch_extract_rbs_single(int **rxdataF,
 
     if ((frame_parms->N_RB_DL&1) == 0)  // even number of RBs
       for (rb=0;rb<frame_parms->N_RB_DL;rb++) {
-	
-	if (rb < 32)
-	  rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
-	else if (rb < 64)
-	  rb_alloc_ind = (rb_alloc[1]>>(rb-32)) & 1;
-	else if (rb < 96)
-	  rb_alloc_ind = (rb_alloc[2]>>(rb-64)) & 1;
-	else if (rb < 100)
-	  rb_alloc_ind = (rb_alloc[3]>>(rb-96)) & 1;
-	else
-	  rb_alloc_ind = 0;
-	
-	// For second half of RBs skip DC carrier
-	if (rb==(frame_parms->N_RB_DL>>1)) {
-	  rxF       = &rxdataF[aarx][(1 + (symbol*(frame_parms->ofdm_symbol_size)))];
-	  //dl_ch0++; 
-	}
-	
-	if (rb_alloc_ind==1) {
-	  *pmi_ext = (pmi>>((rb>>2)<<1))&3;
-	  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");
-	  */
-	  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]);*/
-	    }
-	    dl_ch0_ext+=12;
-	    rxF_ext+=12;
-	  }
-	  else {
-	    j=0;
-	    for (i=0;i<12;i++) {
-	      if ((i!=(frame_parms->nushift+poffset)) &&
-		  (i!=((frame_parms->nushift+poffset+6)%12))) {
-		rxF_ext[j]=rxF[i];
-		//		  		  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
-		dl_ch0_ext[j++]=dl_ch0[i];
-		
-	      }
-	    }
-	    dl_ch0_ext+=10;
-	    rxF_ext+=10;
-	  }
-	  nb_rb++;
-	}
-	dl_ch0+=12;
-	rxF+=12;
+        
+        if (rb < 32)
+          rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
+        else if (rb < 64)
+          rb_alloc_ind = (rb_alloc[1]>>(rb-32)) & 1;
+        else if (rb < 96)
+          rb_alloc_ind = (rb_alloc[2]>>(rb-64)) & 1;
+        else if (rb < 100)
+          rb_alloc_ind = (rb_alloc[3]>>(rb-96)) & 1;
+        else
+          rb_alloc_ind = 0;
+        
+        // For second half of RBs skip DC carrier
+        if (rb==(frame_parms->N_RB_DL>>1)) {
+          rxF       = &rxdataF[aarx][(1 + (symbol*(frame_parms->ofdm_symbol_size)))];
+          //dl_ch0++; 
+        }
+        
+        if (rb_alloc_ind==1) {
+          *pmi_ext = (pmi>>((rb>>2)<<1))&3;
+          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");
+          */
+          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]);*/
+            }
+            dl_ch0_ext+=12;
+            rxF_ext+=12;
+          }
+          else {
+            j=0;
+            for (i=0;i<12;i++) {
+              if ((i!=(frame_parms->nushift+poffset)) &&
+                  (i!=((frame_parms->nushift+poffset+6)%12))) {
+                rxF_ext[j]=rxF[i];
+                //                                printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                dl_ch0_ext[j++]=dl_ch0[i];
+                
+              }
+            }
+            dl_ch0_ext+=10;
+            rxF_ext+=10;
+          }
+          nb_rb++;
+        }
+        dl_ch0+=12;
+        rxF+=12;
 
       }
     else {  // Odd number of RBs
       for (rb=0;rb<frame_parms->N_RB_DL>>1;rb++) {
-	//	printf("dlch_ext %d\n",dl_ch0_ext-&dl_ch_estimates_ext[aarx][0]);
-	skip_half=0;
-	if (rb < 32)
-	  rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
-	else if (rb < 64)
-	  rb_alloc_ind = (rb_alloc[1]>>(rb-32)) & 1;
-	else if (rb < 96)
-	  rb_alloc_ind = (rb_alloc[2]>>(rb-64)) & 1;
-	else if (rb < 100)
-	  rb_alloc_ind = (rb_alloc[3]>>(rb-96)) & 1;
-	else
-	  rb_alloc_ind = 0;
-
-
-	// 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))) {
-	  rb_alloc_ind = 0;
-	}
-	//PBCH subframe 0, symbols nsymb>>1 ... nsymb>>1 + 3
-	if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
-	  skip_half=1;
-	else if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
-	  skip_half=2;
-	
-	//SSS
-
-	if (((subframe==0)||(subframe==5)) && 
-	    (rb>((frame_parms->N_RB_DL>>1)-3)) && 
-	    (rb<((frame_parms->N_RB_DL>>1)+3)) && 
-	    (l==sss_symb) ) {
-	  rb_alloc_ind = 0;
-	}
-	//SSS 
-	if (((subframe==0)||(subframe==5)) && 
-	    (rb==((frame_parms->N_RB_DL>>1)-3)) && 
-	    (l==sss_symb))
-	  skip_half=1;
-	else if (((subframe==0)||(subframe==5)) && 
-		 (rb==((frame_parms->N_RB_DL>>1)+3)) && 
-		 (l==sss_symb))
-	  skip_half=2;
-
-	//PSS in subframe 0/5 if FDD
-	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_alloc_ind = 0;
-	  }
-	  if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l==pss_symb))
-	    skip_half=1;
-	  else if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
-	    skip_half=2;
-	}
-	
-	if ((frame_parms->frame_type == TDD) &&
-	    (subframe==6)){  //TDD Subframe 6
-	  if ((rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb) ) {
-	    rb_alloc_ind = 0;
-	  }
-	  if ((rb==((frame_parms->N_RB_DL>>1)-3)) && (l==pss_symb))
-	    skip_half=1;
-	  else if ((rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
-	    skip_half=2;
-	}
-
-
-	if (rb_alloc_ind==1) {
-	  //	  printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half);
-
-	  if (pilots==0) {
-	    //	    	    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];
-	      dl_ch0_ext+=6;
-	      rxF_ext+=6;
-	    }
-	    else if (skip_half==2) {
-	      memcpy(dl_ch0_ext,dl_ch0+6,6*sizeof(int));
-	      for (i=0;i<6;i++)
-		rxF_ext[i]=rxF[(i+6)];
-	      dl_ch0_ext+=6;
-	      rxF_ext+=6;
-	    }
-	    else {
-	      memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int));
-	      for (i=0;i<12;i++)
-		rxF_ext[i]=rxF[i];
-	      dl_ch0_ext+=12;
-	      rxF_ext+=12;
-	    }
-	  }
-	  else {
-	    //	    	    printf("Extracting with pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half);
-	    j=0;
-	    if (skip_half==1) {
-	      for (i=0;i<6;i++) {
-		if (i!=((frame_parms->nushift+poffset)%6)) {
-		  rxF_ext[j]=rxF[i];
-		  //		  		  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
-		  dl_ch0_ext[j++]=dl_ch0[i];
-		}
-	      }
-	      dl_ch0_ext+=5;
-	      rxF_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)];
-		  //		  		  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
-		  dl_ch0_ext[j++]=dl_ch0[i+6];
-		}
-	      }
-	      dl_ch0_ext+=5;
-	      rxF_ext+=5;
-	    }
-	    else {
-	      for (i=0;i<12;i++) {
-		if ((i!=(frame_parms->nushift+poffset)) &&
-		    (i!=((frame_parms->nushift+poffset+6)%12))) {
-		  rxF_ext[j]=rxF[i];
-		  //		  		  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
-		  dl_ch0_ext[j++]=dl_ch0[i];
-		  
-		}
-	      }
-	      dl_ch0_ext+=10;
-	      rxF_ext+=10;
-	    }
-	  }
-	  nb_rb++;
-	}	    
-	dl_ch0+=12;
-	rxF+=12;
+        //      printf("dlch_ext %d\n",dl_ch0_ext-&dl_ch_estimates_ext[aarx][0]);
+        skip_half=0;
+        if (rb < 32)
+          rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
+        else if (rb < 64)
+          rb_alloc_ind = (rb_alloc[1]>>(rb-32)) & 1;
+        else if (rb < 96)
+          rb_alloc_ind = (rb_alloc[2]>>(rb-64)) & 1;
+        else if (rb < 100)
+          rb_alloc_ind = (rb_alloc[3]>>(rb-96)) & 1;
+        else
+          rb_alloc_ind = 0;
+
+
+        // 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))) {
+          rb_alloc_ind = 0;
+        }
+        //PBCH subframe 0, symbols nsymb>>1 ... nsymb>>1 + 3
+        if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
+          skip_half=1;
+        else if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
+          skip_half=2;
+        
+        //SSS
+
+        if (((subframe==0)||(subframe==5)) && 
+            (rb>((frame_parms->N_RB_DL>>1)-3)) && 
+            (rb<((frame_parms->N_RB_DL>>1)+3)) && 
+            (l==sss_symb) ) {
+          rb_alloc_ind = 0;
+        }
+        //SSS 
+        if (((subframe==0)||(subframe==5)) && 
+            (rb==((frame_parms->N_RB_DL>>1)-3)) && 
+            (l==sss_symb))
+          skip_half=1;
+        else if (((subframe==0)||(subframe==5)) && 
+                 (rb==((frame_parms->N_RB_DL>>1)+3)) && 
+                 (l==sss_symb))
+          skip_half=2;
+
+        //PSS in subframe 0/5 if FDD
+        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_alloc_ind = 0;
+          }
+          if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l==pss_symb))
+            skip_half=1;
+          else if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
+            skip_half=2;
+        }
+        
+        if ((frame_parms->frame_type == TDD) &&
+            (subframe==6)){  //TDD Subframe 6
+          if ((rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb) ) {
+            rb_alloc_ind = 0;
+          }
+          if ((rb==((frame_parms->N_RB_DL>>1)-3)) && (l==pss_symb))
+            skip_half=1;
+          else if ((rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
+            skip_half=2;
+        }
+
+
+        if (rb_alloc_ind==1) {
+          //      printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half);
+
+          if (pilots==0) {
+            //              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];
+              dl_ch0_ext+=6;
+              rxF_ext+=6;
+            }
+            else if (skip_half==2) {
+              memcpy(dl_ch0_ext,dl_ch0+6,6*sizeof(int));
+              for (i=0;i<6;i++)
+                rxF_ext[i]=rxF[(i+6)];
+              dl_ch0_ext+=6;
+              rxF_ext+=6;
+            }
+            else {
+              memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int));
+              for (i=0;i<12;i++)
+                rxF_ext[i]=rxF[i];
+              dl_ch0_ext+=12;
+              rxF_ext+=12;
+            }
+          }
+          else {
+            //              printf("Extracting with pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half);
+            j=0;
+            if (skip_half==1) {
+              for (i=0;i<6;i++) {
+                if (i!=((frame_parms->nushift+poffset)%6)) {
+                  rxF_ext[j]=rxF[i];
+                  //                              printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  dl_ch0_ext[j++]=dl_ch0[i];
+                }
+              }
+              dl_ch0_ext+=5;
+              rxF_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)];
+                  //                              printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  dl_ch0_ext[j++]=dl_ch0[i+6];
+                }
+              }
+              dl_ch0_ext+=5;
+              rxF_ext+=5;
+            }
+            else {
+              for (i=0;i<12;i++) {
+                if ((i!=(frame_parms->nushift+poffset)) &&
+                    (i!=((frame_parms->nushift+poffset+6)%12))) {
+                  rxF_ext[j]=rxF[i];
+                  //                              printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  dl_ch0_ext[j++]=dl_ch0[i];
+                  
+                }
+              }
+              dl_ch0_ext+=10;
+              rxF_ext+=10;
+            }
+          }
+          nb_rb++;
+        }           
+        dl_ch0+=12;
+        rxF+=12;
       } // first half loop
 
 
       // Do middle RB (around DC)
       if (rb < 32)
-	rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
+        rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
       else if (rb < 64)
-	rb_alloc_ind = (rb_alloc[1]>>(rb-32)) & 1;
+        rb_alloc_ind = (rb_alloc[1]>>(rb-32)) & 1;
       else if (rb < 96)
-	rb_alloc_ind = (rb_alloc[2]>>(rb-64)) & 1;
+        rb_alloc_ind = (rb_alloc[2]>>(rb-64)) & 1;
       else if (rb < 100)
-	rb_alloc_ind = (rb_alloc[3]>>(rb-96)) & 1;
+        rb_alloc_ind = (rb_alloc[3]>>(rb-96)) & 1;
       else
-	rb_alloc_ind = 0;
+        rb_alloc_ind = 0;
 
 
 
       // 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))) {
-	rb_alloc_ind = 0;
+        rb_alloc_ind = 0;
       }
       //SSS
       if (((subframe==0)||(subframe==5)) && (rb>=((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==sss_symb) ) {
-	rb_alloc_ind = 0;
+        rb_alloc_ind = 0;
       }
       if (frame_parms->frame_type == FDD) {
-	//PSS
-	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_alloc_ind = 0;
-	}
+        //PSS
+        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_alloc_ind = 0;
+        }
       }
 
       if ((frame_parms->frame_type == TDD) &&
-	  (subframe==6)){
-	//PSS
-	if ((rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb) ) {
-	  rb_alloc_ind = 0;
-	}
+          (subframe==6)){
+        //PSS
+        if ((rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb) ) {
+          rb_alloc_ind = 0;
+        }
       }
-      //	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]);      
       //      printf("DC rb %d (%p)\n",rb,rxF);
       if (rb_alloc_ind==1) {
-	//	printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half);
-	if (pilots==0) {
-	  for (i=0;i<6;i++) {
-	    dl_ch0_ext[i]=dl_ch0[i];
-	    rxF_ext[i]=rxF[i];
-	  }
-	  rxF       = &rxdataF[aarx][((symbol*(frame_parms->ofdm_symbol_size)))];
-	  for (;i<12;i++) {
-	    dl_ch0_ext[i]=dl_ch0[i];
-	    rxF_ext[i]=rxF[(1+i-6)];
-	  }
-	  dl_ch0_ext+=12;
-	  rxF_ext+=12;
-	}
-	else { // pilots==1
-	  j=0;
-	  for (i=0;i<6;i++) {
-	    if (i!=((frame_parms->nushift+poffset)%6)) {
-	      dl_ch0_ext[j]=dl_ch0[i];
-	      rxF_ext[j++]=rxF[i];
-	      //	           	      printf("**extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j-1],*(1+(short*)&rxF_ext[j-1]));
-	    }
-	  }
-	  rxF       = &rxdataF[aarx][((symbol*(frame_parms->ofdm_symbol_size)))];
-	  for (;i<12;i++) {
-	    if (i!=((frame_parms->nushift+6+poffset)%12)) {
-	      dl_ch0_ext[j]=dl_ch0[i];
-	      rxF_ext[j++]=rxF[(1+i-6)];
-	      //	            	      printf("**extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j-1],*(1+(short*)&rxF_ext[j-1]));
-	    }
-	  }
-	  dl_ch0_ext+=10;
-	  rxF_ext+=10;
-	} // symbol_mod==0
-	nb_rb++;
+        //      printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half);
+        if (pilots==0) {
+          for (i=0;i<6;i++) {
+            dl_ch0_ext[i]=dl_ch0[i];
+            rxF_ext[i]=rxF[i];
+          }
+          rxF       = &rxdataF[aarx][((symbol*(frame_parms->ofdm_symbol_size)))];
+          for (;i<12;i++) {
+            dl_ch0_ext[i]=dl_ch0[i];
+            rxF_ext[i]=rxF[(1+i-6)];
+          }
+          dl_ch0_ext+=12;
+          rxF_ext+=12;
+        }
+        else { // pilots==1
+          j=0;
+          for (i=0;i<6;i++) {
+            if (i!=((frame_parms->nushift+poffset)%6)) {
+              dl_ch0_ext[j]=dl_ch0[i];
+              rxF_ext[j++]=rxF[i];
+              //                              printf("**extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j-1],*(1+(short*)&rxF_ext[j-1]));
+            }
+          }
+          rxF       = &rxdataF[aarx][((symbol*(frame_parms->ofdm_symbol_size)))];
+          for (;i<12;i++) {
+            if (i!=((frame_parms->nushift+6+poffset)%12)) {
+              dl_ch0_ext[j]=dl_ch0[i];
+              rxF_ext[j++]=rxF[(1+i-6)];
+              //                              printf("**extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j-1],*(1+(short*)&rxF_ext[j-1]));
+            }
+          }
+          dl_ch0_ext+=10;
+          rxF_ext+=10;
+        } // symbol_mod==0
+        nb_rb++;
       } // rballoc==1
       else {
-	rxF       = &rxdataF[aarx][((symbol*(frame_parms->ofdm_symbol_size)))];
+        rxF       = &rxdataF[aarx][((symbol*(frame_parms->ofdm_symbol_size)))];
       }
       dl_ch0+=12;
       rxF+=7;
       rb++;
       
       for (;rb<frame_parms->N_RB_DL;rb++) {
-	//	printf("dlch_ext %d\n",dl_ch0_ext-&dl_ch_estimates_ext[aarx][0]);	
-	//	printf("rb %d (%p)\n",rb,rxF);
-	skip_half=0;
-	if (rb < 32)
-	  rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
-	else if (rb < 64)
-	  rb_alloc_ind = (rb_alloc[1]>>(rb-32)) & 1;
-	else if (rb < 96)
-	  rb_alloc_ind = (rb_alloc[2]>>(rb-64)) & 1;
-	else if (rb < 100)
-	  rb_alloc_ind = (rb_alloc[3]>>(rb-96)) & 1;
-	else
-	  rb_alloc_ind = 0;
-
-
-
-	// 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))) {
-	  rb_alloc_ind = 0;
-	}
-	//PBCH subframe 0, symbols nsymb>>1 ... nsymb>>1 + 3
-	if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
-	  skip_half=1;
-	else if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
-	  skip_half=2;
-	//SSS
-	if (((subframe==0)||(subframe==5)) && (rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==sss_symb) ) {
-	  rb_alloc_ind = 0;
-	}
-	//SSS 
-	if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l==sss_symb))
-	  skip_half=1;
-	else if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l==sss_symb))
-	  skip_half=2;
+        //      printf("dlch_ext %d\n",dl_ch0_ext-&dl_ch_estimates_ext[aarx][0]);       
+        //      printf("rb %d (%p)\n",rb,rxF);
+        skip_half=0;
+        if (rb < 32)
+          rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
+        else if (rb < 64)
+          rb_alloc_ind = (rb_alloc[1]>>(rb-32)) & 1;
+        else if (rb < 96)
+          rb_alloc_ind = (rb_alloc[2]>>(rb-64)) & 1;
+        else if (rb < 100)
+          rb_alloc_ind = (rb_alloc[3]>>(rb-96)) & 1;
+        else
+          rb_alloc_ind = 0;
+
+
+
+        // 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))) {
+          rb_alloc_ind = 0;
+        }
+        //PBCH subframe 0, symbols nsymb>>1 ... nsymb>>1 + 3
+        if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
+          skip_half=1;
+        else if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
+          skip_half=2;
+        //SSS
+        if (((subframe==0)||(subframe==5)) && (rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==sss_symb) ) {
+          rb_alloc_ind = 0;
+        }
+        //SSS 
+        if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l==sss_symb))
+          skip_half=1;
+        else if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l==sss_symb))
+          skip_half=2;
       
-	if (frame_parms->frame_type == FDD) {
-	  //PSS
-	  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_alloc_ind = 0;
-	  }
-	  //PSS 
-	  if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l==pss_symb))
-	    skip_half=1;
-	  else if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
-	    skip_half=2;
-	}
-
-	if ((frame_parms->frame_type == TDD) &&
-	    (subframe==6)){  //TDD Subframe 6
-	  if ((rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb) ) {
-	    rb_alloc_ind = 0;
-	  }
-	  if ((rb==((frame_parms->N_RB_DL>>1)-3)) && (l==pss_symb))
-	    skip_half=1;
-	  else if ((rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
-	    skip_half=2;
-	}
-	
-	if (rb_alloc_ind==1) {
-	  //	  printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half);
-	  /*
-  	    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);
-	    if (skip_half==1) {
-	      memcpy(dl_ch0_ext,dl_ch0,6*sizeof(int));
-	      for (i=0;i<6;i++)
-		rxF_ext[i]=rxF[i];
-	      dl_ch0_ext+=6;
-	      rxF_ext+=6;
-
-	    }
-	    else if (skip_half==2) {
-	      memcpy(dl_ch0_ext,dl_ch0+6,6*sizeof(int));
-	      for (i=0;i<6;i++)
-		rxF_ext[i]=rxF[(i+6)];
-	      dl_ch0_ext+=6;
-	      rxF_ext+=6;
-
-	    }
-	    else {
-	      memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int));
-	      for (i=0;i<12;i++)
-		rxF_ext[i]=rxF[i];
-	      dl_ch0_ext+=12;
-	      rxF_ext+=12;
-	    }
-	  }
-	  else {
-	    //	    	    printf("Extracting with pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half);
-	    j=0;
-	    if (skip_half==1) {
-	      for (i=0;i<6;i++) {
-		if (i!=((frame_parms->nushift+poffset)%6)) {
-		  rxF_ext[j]=rxF[i];
-		  //		  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
-		  dl_ch0_ext[j++]=dl_ch0[i];
-		}
-	      }
-	      dl_ch0_ext+=5;
-	      rxF_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)];
-		  //		  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
-		  dl_ch0_ext[j++]=dl_ch0[i+6];
-		}
-	      }
-	      dl_ch0_ext+=5;
-	      rxF_ext+=5;
-	    }
-	    else {
-	      for (i=0;i<12;i++) {
-		if ((i!=(frame_parms->nushift+poffset)) &&
-		    (i!=((frame_parms->nushift+poffset+6)%12))) {
-		  rxF_ext[j]=rxF[i];
-		  //		  printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
-		  dl_ch0_ext[j++]=dl_ch0[i];
-		}
-	      }
-	      dl_ch0_ext+=10;
-	      rxF_ext+=10;
-	    }
-	  } // pilots=0
-	  nb_rb++;
-	}
-	dl_ch0+=12;
-	rxF+=12;
+        if (frame_parms->frame_type == FDD) {
+          //PSS
+          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_alloc_ind = 0;
+          }
+          //PSS 
+          if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l==pss_symb))
+            skip_half=1;
+          else if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
+            skip_half=2;
+        }
+
+        if ((frame_parms->frame_type == TDD) &&
+            (subframe==6)){  //TDD Subframe 6
+          if ((rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb) ) {
+            rb_alloc_ind = 0;
+          }
+          if ((rb==((frame_parms->N_RB_DL>>1)-3)) && (l==pss_symb))
+            skip_half=1;
+          else if ((rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
+            skip_half=2;
+        }
+        
+        if (rb_alloc_ind==1) {
+          //      printf("rb %d/symbol %d (skip_half %d)\n",rb,l,skip_half);
+          /*
+            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);
+            if (skip_half==1) {
+              memcpy(dl_ch0_ext,dl_ch0,6*sizeof(int));
+              for (i=0;i<6;i++)
+                rxF_ext[i]=rxF[i];
+              dl_ch0_ext+=6;
+              rxF_ext+=6;
+
+            }
+            else if (skip_half==2) {
+              memcpy(dl_ch0_ext,dl_ch0+6,6*sizeof(int));
+              for (i=0;i<6;i++)
+                rxF_ext[i]=rxF[(i+6)];
+              dl_ch0_ext+=6;
+              rxF_ext+=6;
+
+            }
+            else {
+              memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int));
+              for (i=0;i<12;i++)
+                rxF_ext[i]=rxF[i];
+              dl_ch0_ext+=12;
+              rxF_ext+=12;
+            }
+          }
+          else {
+            //              printf("Extracting with pilots (symbol %d, rb %d, skip_half %d)\n",l,rb,skip_half);
+            j=0;
+            if (skip_half==1) {
+              for (i=0;i<6;i++) {
+                if (i!=((frame_parms->nushift+poffset)%6)) {
+                  rxF_ext[j]=rxF[i];
+                  //              printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  dl_ch0_ext[j++]=dl_ch0[i];
+                }
+              }
+              dl_ch0_ext+=5;
+              rxF_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)];
+                  //              printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  dl_ch0_ext[j++]=dl_ch0[i+6];
+                }
+              }
+              dl_ch0_ext+=5;
+              rxF_ext+=5;
+            }
+            else {
+              for (i=0;i<12;i++) {
+                if ((i!=(frame_parms->nushift+poffset)) &&
+                    (i!=((frame_parms->nushift+poffset+6)%12))) {
+                  rxF_ext[j]=rxF[i];
+                  //              printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  dl_ch0_ext[j++]=dl_ch0[i];
+                }
+              }
+              dl_ch0_ext+=10;
+              rxF_ext+=10;
+            }
+          } // pilots=0
+          nb_rb++;
+        }
+        dl_ch0+=12;
+        rxF+=12;
       }
     }
   }
@@ -2740,7 +3066,7 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
                                       unsigned int *rb_alloc,
                                       unsigned char symbol,
                                       unsigned char subframe,
-				      uint32_t high_speed_flag,
+                                      uint32_t high_speed_flag,
                                       LTE_DL_FRAME_PARMS *frame_parms) {
     
 
@@ -2787,284 +3113,284 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
 
     if ((frame_parms->N_RB_DL&1) == 0)  // even number of RBs
       for (rb=0;rb<frame_parms->N_RB_DL;rb++) {
-	skip_half=0;
-	if (rb < 32)
-	  rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
-	else if (rb < 64)
-	  rb_alloc_ind = (rb_alloc[1]>>(rb-32)) & 1;
-	else if (rb < 96)
-	  rb_alloc_ind = (rb_alloc[2]>>(rb-64)) & 1;
-	else if (rb < 100)
-	  rb_alloc_ind = (rb_alloc[3]>>(rb-96)) & 1;
-	else
-	  rb_alloc_ind = 0;
-	
-	// For second half of RBs skip DC carrier
-	if (rb==(frame_parms->N_RB_DL>>1)) {
-	  rxF       = &rxdataF[aarx][(1 + (symbol*(frame_parms->ofdm_symbol_size)))];
-	  //dl_ch0++;
-	  //dl_ch1++;
-	}
-
-	// 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))) {
-	  rb_alloc_ind = 0;
-	}
-	
-	//SSS
+        skip_half=0;
+        if (rb < 32)
+          rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
+        else if (rb < 64)
+          rb_alloc_ind = (rb_alloc[1]>>(rb-32)) & 1;
+        else if (rb < 96)
+          rb_alloc_ind = (rb_alloc[2]>>(rb-64)) & 1;
+        else if (rb < 100)
+          rb_alloc_ind = (rb_alloc[3]>>(rb-96)) & 1;
+        else
+          rb_alloc_ind = 0;
+        
+        // For second half of RBs skip DC carrier
+        if (rb==(frame_parms->N_RB_DL>>1)) {
+          rxF       = &rxdataF[aarx][(1 + (symbol*(frame_parms->ofdm_symbol_size)))];
+          //dl_ch0++;
+          //dl_ch1++;
+        }
+
+        // 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))) {
+          rb_alloc_ind = 0;
+        }
+        
+        //SSS
 
-	if (((subframe==0)||(subframe==5)) && 
-	    (rb>=((frame_parms->N_RB_DL>>1)-3)) && 
-	    (rb<((frame_parms->N_RB_DL>>1)+3)) && 
-	    (l==sss_symb) ) {
-	  rb_alloc_ind = 0;
-	}
+        if (((subframe==0)||(subframe==5)) && 
+            (rb>=((frame_parms->N_RB_DL>>1)-3)) && 
+            (rb<((frame_parms->N_RB_DL>>1)+3)) && 
+            (l==sss_symb) ) {
+          rb_alloc_ind = 0;
+        }
 
 
 
-	//PSS in subframe 0/5 if FDD
-	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_alloc_ind = 0;
-	  }
-	}
-	
-	if ((frame_parms->frame_type == TDD) &&
-	    (subframe==6)){  //TDD Subframe 6
-	  if ((rb>=((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb) ) {
-	    rb_alloc_ind = 0;
-	  }
-	}
+        //PSS in subframe 0/5 if FDD
+        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_alloc_ind = 0;
+          }
+        }
+        
+        if ((frame_parms->frame_type == TDD) &&
+            (subframe==6)){  //TDD Subframe 6
+          if ((rb>=((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb) ) {
+            rb_alloc_ind = 0;
+          }
+        }
 
-	if (rb_alloc_ind==1) {
+        if (rb_alloc_ind==1) {
 
           //printf("demod: rb %d\n",rb);
 
-	  *pmi_loc = (pmi>>((rb>>2)<<1))&3;
-	  //	  printf("rb %d: sb %d : pmi %d\n",rb,rb>>2,*pmi_loc);
+          *pmi_loc = (pmi>>((rb>>2)<<1))&3;
+          //      printf("rb %d: sb %d : pmi %d\n",rb,rb>>2,*pmi_loc);
 
-	  pmi_loc++;
+          pmi_loc++;
 
 
-	  if (pilots == 0) {
+          if (pilots == 0) {
 
-	    memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int));
-	    memcpy(dl_ch1_ext,dl_ch1,12*sizeof(int));
-	    /*
-	      printf("rb %d\n",rb);
-	      for (i=0;i<12;i++)
-	      printf("(%d %d)",((short *)dl_ch)[i<<1],((short*)dl_ch)[1+(i<<1)]);
-	      printf("\n");*/
-	    
-	    for (i=0;i<12;i++) {
-	      rxF_ext[i]=rxF[i];
-	      //	      printf("%d : (%d,%d)\n",(rxF+(2*i)-&rxdataF[(aatx<<1)+aarx][( (symbol*(frame_parms->ofdm_symbol_size)))*2])/2,
-	      //     ((short*)&rxF[i<<1])[0],((short*)&rxF[i<<1])[0]);
-	    }
-	    dl_ch0_ext+=12;
-	    dl_ch1_ext+=12;
-	    rxF_ext+=12;
-	  }
-	  else {
-	    j=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];
-		//	      printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
-		dl_ch0_ext[j]=dl_ch0[i];
-		dl_ch1_ext[j++]=dl_ch1[i];
-	      }
-	    }
-	    dl_ch0_ext+=8;
-	    dl_ch1_ext+=8;
-	    rxF_ext+=8;
-	  } // pilots==1
-	  
-	  nb_rb++;
+            memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int));
+            memcpy(dl_ch1_ext,dl_ch1,12*sizeof(int));
+            /*
+              printf("rb %d\n",rb);
+              for (i=0;i<12;i++)
+              printf("(%d %d)",((short *)dl_ch)[i<<1],((short*)dl_ch)[1+(i<<1)]);
+              printf("\n");*/
+            
+            for (i=0;i<12;i++) {
+              rxF_ext[i]=rxF[i];
+              //              printf("%d : (%d,%d)\n",(rxF+(2*i)-&rxdataF[(aatx<<1)+aarx][( (symbol*(frame_parms->ofdm_symbol_size)))*2])/2,
+              //     ((short*)&rxF[i<<1])[0],((short*)&rxF[i<<1])[0]);
+            }
+            dl_ch0_ext+=12;
+            dl_ch1_ext+=12;
+            rxF_ext+=12;
+          }
+          else {
+            j=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];
+                //            printf("extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                dl_ch0_ext[j]=dl_ch0[i];
+                dl_ch1_ext[j++]=dl_ch1[i];
+              }
+            }
+            dl_ch0_ext+=8;
+            dl_ch1_ext+=8;
+            rxF_ext+=8;
+          } // pilots==1
+          
+          nb_rb++;
 
-	}
-	dl_ch0+=12;
-	dl_ch1+=12;
-	rxF+=12;
+        }
+        dl_ch0+=12;
+        dl_ch1+=12;
+        rxF+=12;
       }
     else {  // Odd number of RBs
       for (rb=0;rb<frame_parms->N_RB_DL>>1;rb++) {
-	skip_half=0;
-	if (rb < 32)
-	  rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
-	else if (rb < 64)
-	  rb_alloc_ind = (rb_alloc[1]>>(rb-32)) & 1;
-	else if (rb < 96)
-	  rb_alloc_ind = (rb_alloc[2]>>(rb-64)) & 1;
-	else if (rb < 100)
-	  rb_alloc_ind = (rb_alloc[3]>>(rb-96)) & 1;
-	else
-	  rb_alloc_ind = 0;
-
-
-
-	// 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))) {
-	  rb_alloc_ind = 0;
-	}
-	//PBCH subframe 0, symbols nsymb>>1 ... nsymb>>1 + 3
-	if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
-	  skip_half=1;
-	else if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
-	  skip_half=2;
-	
-	//SSS
-
-	if (((subframe==0)||(subframe==5)) && 
-	    (rb>((frame_parms->N_RB_DL>>1)-3)) && 
-	    (rb<((frame_parms->N_RB_DL>>1)+3)) && 
-	    (l==sss_symb) ) {
-	  rb_alloc_ind = 0;
-	}
-	//SSS 
-	if (((subframe==0)||(subframe==5)) && 
-	    (rb==((frame_parms->N_RB_DL>>1)-3)) && 
-	    (l==sss_symb))
-	  skip_half=1;
-	else if (((subframe==0)||(subframe==5)) && 
-		 (rb==((frame_parms->N_RB_DL>>1)+3)) && 
-		 (l==sss_symb))
-	  skip_half=2;
-	
-	//PSS in subframe 0/5 if FDD
-	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_alloc_ind = 0;
-	  }
-	  if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l==pss_symb))
-	    skip_half=1;
-	  else if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
-	    skip_half=2;
-	}
-	
-	if ((frame_parms->frame_type == TDD) &&
-	    (subframe==6)){  //TDD Subframe 6
-	  if ((rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb) ) {
-	    rb_alloc_ind = 0;
-	  }
-	  if ((rb==((frame_parms->N_RB_DL>>1)-3)) && (l==pss_symb))
-	    skip_half=1;
-	  else if ((rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
-	    skip_half=2;
-	}
-	//	printf("rb %d: alloc %d skip_half %d (rxF %p, rxF_ext %p)\n",rb,rb_alloc_ind,skip_half,rxF,rxF_ext);
-
-	if (rb_alloc_ind==1) {
-
-	  *pmi_loc = (pmi>>((rb>>2)<<1))&3;
-	  //	  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,rb,rb>>2,*pmi_loc,pmi_loc,rxF,dl_ch0, dl_ch1, rxF_ext,dl_ch0_ext,dl_ch1_ext);
-	  
-	  pmi_loc++;
-	  if (pilots==0) {
-	    if (skip_half==1) {
-	      memcpy(dl_ch0_ext,dl_ch0,6*sizeof(int));
-	      memcpy(dl_ch1_ext,dl_ch1,6*sizeof(int));
-	      for (i=0;i<6;i++)
-		rxF_ext[i]=rxF[i];
-	      dl_ch0_ext+=6;
-	      dl_ch1_ext+=6;
-	      rxF_ext+=6;
-	    }
-	    else if (skip_half==2) {
-	      memcpy(dl_ch0_ext,dl_ch0+6,6*sizeof(int));
-	      memcpy(dl_ch1_ext,dl_ch1+6,6*sizeof(int));
-	      for (i=0;i<6;i++)
-		rxF_ext[i]=rxF[(i+6)];
-	      dl_ch0_ext+=6;
-	      dl_ch1_ext+=6;
-	      rxF_ext+=6;
-	    }
-	    else {
-	      memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int));
-	      memcpy(dl_ch1_ext,dl_ch1,12*sizeof(int));
-	      for (i=0;i<12;i++)
-		rxF_ext[i]=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];
-		  //	  printf("(pilots,skip1)extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
-		  dl_ch0_ext[j]=dl_ch0[i];
-		  dl_ch1_ext[j++]=dl_ch1[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)];
-		  //	      printf("(pilots,skip2)extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
-		  dl_ch0_ext[j]=dl_ch0[i+6];
-		  dl_ch1_ext[j++]=dl_ch1[i+6];
-		}
-		
-		dl_ch0_ext+=4;
-		dl_ch1_ext+=4;
-		rxF_ext+=4;
-	      }
-	    }
-	    else {
-	      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];
-		  //	  printf("(pilots)extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
-		  
-		  dl_ch0_ext[j]  =dl_ch0[i];
-		  dl_ch1_ext[j++]=dl_ch1[i];
-		  
-		  //			      printf("extract rb %d, re %d => ch0 (%d,%d) ch1 (%d,%d)\n",rb,i,
-		  //				     *(short *)&dl_ch0_ext[j-1],*(1+(short*)&dl_ch0_ext[j-1]),
-		  //				     *(short *)&dl_ch1_ext[j-1],*(1+(short*)&dl_ch1_ext[j-1]));
-		}
-	      }
-	      dl_ch0_ext+=8;
-	      dl_ch1_ext+=8;
-	      rxF_ext+=8;		
-	    }
-	  }
-	  nb_rb++;
-	}
+        skip_half=0;
+        if (rb < 32)
+          rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
+        else if (rb < 64)
+          rb_alloc_ind = (rb_alloc[1]>>(rb-32)) & 1;
+        else if (rb < 96)
+          rb_alloc_ind = (rb_alloc[2]>>(rb-64)) & 1;
+        else if (rb < 100)
+          rb_alloc_ind = (rb_alloc[3]>>(rb-96)) & 1;
+        else
+          rb_alloc_ind = 0;
+
+
+
+        // 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))) {
+          rb_alloc_ind = 0;
+        }
+        //PBCH subframe 0, symbols nsymb>>1 ... nsymb>>1 + 3
+        if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
+          skip_half=1;
+        else if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
+          skip_half=2;
+        
+        //SSS
+
+        if (((subframe==0)||(subframe==5)) && 
+            (rb>((frame_parms->N_RB_DL>>1)-3)) && 
+            (rb<((frame_parms->N_RB_DL>>1)+3)) && 
+            (l==sss_symb) ) {
+          rb_alloc_ind = 0;
+        }
+        //SSS 
+        if (((subframe==0)||(subframe==5)) && 
+            (rb==((frame_parms->N_RB_DL>>1)-3)) && 
+            (l==sss_symb))
+          skip_half=1;
+        else if (((subframe==0)||(subframe==5)) && 
+                 (rb==((frame_parms->N_RB_DL>>1)+3)) && 
+                 (l==sss_symb))
+          skip_half=2;
+        
+        //PSS in subframe 0/5 if FDD
+        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_alloc_ind = 0;
+          }
+          if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l==pss_symb))
+            skip_half=1;
+          else if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
+            skip_half=2;
+        }
+        
+        if ((frame_parms->frame_type == TDD) &&
+            (subframe==6)){  //TDD Subframe 6
+          if ((rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb) ) {
+            rb_alloc_ind = 0;
+          }
+          if ((rb==((frame_parms->N_RB_DL>>1)-3)) && (l==pss_symb))
+            skip_half=1;
+          else if ((rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
+            skip_half=2;
+        }
+        //      printf("rb %d: alloc %d skip_half %d (rxF %p, rxF_ext %p)\n",rb,rb_alloc_ind,skip_half,rxF,rxF_ext);
+
+        if (rb_alloc_ind==1) {
+
+          *pmi_loc = (pmi>>((rb>>2)<<1))&3;
+          //      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,rb,rb>>2,*pmi_loc,pmi_loc,rxF,dl_ch0, dl_ch1, rxF_ext,dl_ch0_ext,dl_ch1_ext);
+          
+          pmi_loc++;
+          if (pilots==0) {
+            if (skip_half==1) {
+              memcpy(dl_ch0_ext,dl_ch0,6*sizeof(int));
+              memcpy(dl_ch1_ext,dl_ch1,6*sizeof(int));
+              for (i=0;i<6;i++)
+                rxF_ext[i]=rxF[i];
+              dl_ch0_ext+=6;
+              dl_ch1_ext+=6;
+              rxF_ext+=6;
+            }
+            else if (skip_half==2) {
+              memcpy(dl_ch0_ext,dl_ch0+6,6*sizeof(int));
+              memcpy(dl_ch1_ext,dl_ch1+6,6*sizeof(int));
+              for (i=0;i<6;i++)
+                rxF_ext[i]=rxF[(i+6)];
+              dl_ch0_ext+=6;
+              dl_ch1_ext+=6;
+              rxF_ext+=6;
+            }
+            else {
+              memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int));
+              memcpy(dl_ch1_ext,dl_ch1,12*sizeof(int));
+              for (i=0;i<12;i++)
+                rxF_ext[i]=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];
+                  //      printf("(pilots,skip1)extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  dl_ch0_ext[j]=dl_ch0[i];
+                  dl_ch1_ext[j++]=dl_ch1[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)];
+                  //          printf("(pilots,skip2)extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  dl_ch0_ext[j]=dl_ch0[i+6];
+                  dl_ch1_ext[j++]=dl_ch1[i+6];
+                }
+                
+                dl_ch0_ext+=4;
+                dl_ch1_ext+=4;
+                rxF_ext+=4;
+              }
+            }
+            else {
+              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];
+                  //      printf("(pilots)extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  
+                  dl_ch0_ext[j]  =dl_ch0[i];
+                  dl_ch1_ext[j++]=dl_ch1[i];
+                  
+                  //                          printf("extract rb %d, re %d => ch0 (%d,%d) ch1 (%d,%d)\n",rb,i,
+                  //                                 *(short *)&dl_ch0_ext[j-1],*(1+(short*)&dl_ch0_ext[j-1]),
+                  //                                 *(short *)&dl_ch1_ext[j-1],*(1+(short*)&dl_ch1_ext[j-1]));
+                }
+              }
+              dl_ch0_ext+=8;
+              dl_ch1_ext+=8;
+              rxF_ext+=8;               
+            }
+          }
+          nb_rb++;
+        }
       
-	dl_ch0+=12;
-	dl_ch1+=12;
-	rxF+=12;
+        dl_ch0+=12;
+        dl_ch1+=12;
+        rxF+=12;
       }
     
     
       // Do middle RB (around DC)
       if (rb < 32)
-	rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
+        rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
       else if (rb < 64)
-	rb_alloc_ind = (rb_alloc[1]>>(rb-32)) & 1;
+        rb_alloc_ind = (rb_alloc[1]>>(rb-32)) & 1;
       else if (rb < 96)
-	rb_alloc_ind = (rb_alloc[2]>>(rb-64)) & 1;
+        rb_alloc_ind = (rb_alloc[2]>>(rb-64)) & 1;
       else if (rb < 100)
-	rb_alloc_ind = (rb_alloc[0]>>(rb-96)) & 1;
+        rb_alloc_ind = (rb_alloc[0]>>(rb-96)) & 1;
       else
-	rb_alloc_ind = 0;
+        rb_alloc_ind = 0;
       
 
 
@@ -3072,82 +3398,82 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
       
       // 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))) {
-	rb_alloc_ind = 0;
+        rb_alloc_ind = 0;
       }
       //SSS
       if (((subframe==0)||(subframe==5)) && (rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==sss_symb) ) {
-	rb_alloc_ind = 0;
+        rb_alloc_ind = 0;
       }
       if (frame_parms->frame_type == FDD) {
-	//PSS
-	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_alloc_ind = 0;
-	}
+        //PSS
+        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_alloc_ind = 0;
+        }
       }
       
       if ((frame_parms->frame_type == TDD) &&
-	  (subframe==6)){
-	//PSS
-	if ((rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb) ) {
-	  rb_alloc_ind = 0;
-	}
+          (subframe==6)){
+        //PSS
+        if ((rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb) ) {
+          rb_alloc_ind = 0;
+        }
       }
       
       
       if (rb_alloc_ind==1) {
-	
-	*pmi_loc = (pmi>>((rb>>2)<<1))&3;
-	//	printf("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",rb,rb>>2,*pmi_loc,pmi_loc,rxF,dl_ch0, dl_ch1, rxF_ext,dl_ch0_ext,dl_ch1_ext);
-	pmi_loc++;
-	
-	if (pilots==0) {
-	  for (i=0;i<6;i++) {
-	    dl_ch0_ext[i]=dl_ch0[i];
-	    dl_ch1_ext[i]=dl_ch1[i];
-	    rxF_ext[i]=rxF[i];
-	  }
-	  rxF       = &rxdataF[aarx][((symbol*(frame_parms->ofdm_symbol_size)))];
-	  for (;i<12;i++) {
-	    dl_ch0_ext[i]=dl_ch0[i];
-	    dl_ch1_ext[i]=dl_ch1[i];
-	    rxF_ext[i]=rxF[(1+i-6)];
-	  }
-	  dl_ch0_ext+=12;
-	  dl_ch1_ext+=12;
-	  rxF_ext+=12;	
-	}
-	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_ch0[i];
-	      dl_ch1_ext[j]=dl_ch1[i];
-	      rxF_ext[j++]=rxF[i];
-	      //     	      printf("(pilots center)extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j-1],*(1+(short*)&rxF_ext[j-1]));
-	      //	      printf("extract rb %d, re %d => ch0 (%d,%d) ch1 (%d,%d)\n",rb,i,
-	      //		     *(short *)&dl_ch0_ext[j-1],*(1+(short*)&dl_ch0_ext[j-1]),
-	      //		     *(short *)&dl_ch1_ext[j-1],*(1+(short*)&dl_ch1_ext[j-1]));
-	    }
-	  }
-	  rxF       = &rxdataF[aarx][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_ch0[i];
-	      dl_ch1_ext[j]=dl_ch1[i];
-	      rxF_ext[j++]=rxF[(1+i-6)];
-	    }
-	  }
-	  dl_ch0_ext+=8;
-	  dl_ch1_ext+=8;
-	  rxF_ext+=8; 
-	}
-	nb_rb++;
+        
+        *pmi_loc = (pmi>>((rb>>2)<<1))&3;
+        //      printf("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",rb,rb>>2,*pmi_loc,pmi_loc,rxF,dl_ch0, dl_ch1, rxF_ext,dl_ch0_ext,dl_ch1_ext);
+        pmi_loc++;
+        
+        if (pilots==0) {
+          for (i=0;i<6;i++) {
+            dl_ch0_ext[i]=dl_ch0[i];
+            dl_ch1_ext[i]=dl_ch1[i];
+            rxF_ext[i]=rxF[i];
+          }
+          rxF       = &rxdataF[aarx][((symbol*(frame_parms->ofdm_symbol_size)))];
+          for (;i<12;i++) {
+            dl_ch0_ext[i]=dl_ch0[i];
+            dl_ch1_ext[i]=dl_ch1[i];
+            rxF_ext[i]=rxF[(1+i-6)];
+          }
+          dl_ch0_ext+=12;
+          dl_ch1_ext+=12;
+          rxF_ext+=12;  
+        }
+        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_ch0[i];
+              dl_ch1_ext[j]=dl_ch1[i];
+              rxF_ext[j++]=rxF[i];
+              //              printf("(pilots center)extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j-1],*(1+(short*)&rxF_ext[j-1]));
+              //              printf("extract rb %d, re %d => ch0 (%d,%d) ch1 (%d,%d)\n",rb,i,
+              //                     *(short *)&dl_ch0_ext[j-1],*(1+(short*)&dl_ch0_ext[j-1]),
+              //                     *(short *)&dl_ch1_ext[j-1],*(1+(short*)&dl_ch1_ext[j-1]));
+            }
+          }
+          rxF       = &rxdataF[aarx][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_ch0[i];
+              dl_ch1_ext[j]=dl_ch1[i];
+              rxF_ext[j++]=rxF[(1+i-6)];
+            }
+          }
+          dl_ch0_ext+=8;
+          dl_ch1_ext+=8;
+          rxF_ext+=8; 
+        }
+        nb_rb++;
       }
       else {
-	rxF       = &rxdataF[aarx][((symbol*(frame_parms->ofdm_symbol_size)))];
+        rxF       = &rxdataF[aarx][((symbol*(frame_parms->ofdm_symbol_size)))];
       }
       dl_ch0+=12;
       dl_ch1+=12;
@@ -3155,163 +3481,163 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
       rb++;
       
       for (;rb<frame_parms->N_RB_DL;rb++) {
-	skip_half=0;
-	
-	if (rb < 32)
-	  rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
-	else if (rb < 64)
-	  rb_alloc_ind = (rb_alloc[1]>>(rb-32)) & 1;
-	else if (rb < 96)
-	  rb_alloc_ind = (rb_alloc[2]>>(rb-64)) & 1;
-	else if (rb < 100)
-	  rb_alloc_ind = (rb_alloc[3]>>(rb-96)) & 1;
-	else
-	  rb_alloc_ind = 0;
-	
-	
-	// 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))) {
-	  rb_alloc_ind = 0;
-	}
-	//PBCH subframe 0, symbols nsymb>>1 ... nsymb>>1 + 3
-	if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
-	  skip_half=1;
-	else if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
-	  skip_half=2;
-
-	//SSS
-	if (((subframe==0)||(subframe==5)) && (rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==sss_symb) ) {
-	  rb_alloc_ind = 0;
-	}
-	//SSS 
-	if (((subframe==0)||(subframe==5)) && 
-	    (rb==((frame_parms->N_RB_DL>>1)-3)) && 
-	    (l==sss_symb))
-	  skip_half=1;
-	else if (((subframe==0)||(subframe==5)) && 
-		 (rb==((frame_parms->N_RB_DL>>1)+3)) && 
-		 (l==sss_symb))
-	  skip_half=2;
-
-	if (frame_parms->frame_type == FDD) {
-	  //PSS
-	  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_alloc_ind = 0;
-
-	  }
-	  if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l==pss_symb))
-	    skip_half=1;
-	  else if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
-	    skip_half=2;
-	}
-	
-	if ((frame_parms->frame_type == TDD) &&
-	    (subframe==6)){
-	  //PSS
-	  if ((rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb) ) {
-	    rb_alloc_ind = 0;
-	  }
-	  if ((rb==((frame_parms->N_RB_DL>>1)-3)) && (l==pss_symb))
-	    skip_half=1;
-	  else if ((rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
-	    skip_half=2;
-	}
-      	
-	if (rb_alloc_ind==1) {
-	  
-	  *pmi_loc = (pmi>>((rb>>2)<<1))&3;
-	  //  	  printf("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",rb,rb>>2,*pmi_loc,pmi_loc,rxF,dl_ch0, dl_ch1, rxF_ext,dl_ch0_ext,dl_ch1_ext);
-	  
-	  pmi_loc++;
-	  
-	  if (pilots==0) {
-	    if (skip_half==1) {
-	      memcpy(dl_ch0_ext,dl_ch0,6*sizeof(int));
-	      memcpy(dl_ch1_ext,dl_ch1,6*sizeof(int));
-	      for (i=0;i<6;i++)
-		rxF_ext[i]=rxF[i];
-	      dl_ch0_ext+=6;
-	      dl_ch1_ext+=6;
-	      rxF_ext+=6;
-	      
-	    }
-	    else if (skip_half==2) {
-	      memcpy(dl_ch0_ext,dl_ch0+6,6*sizeof(int));
-	      memcpy(dl_ch1_ext,dl_ch1+6,6*sizeof(int));
-	      for (i=0;i<6;i++)
-		rxF_ext[i]=rxF[(i+6)];
-	      dl_ch0_ext+=6;
-	      dl_ch1_ext+=6;
-	      rxF_ext+=6;
-	      
-	    }
-	    else {
-	      memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int));
-	      memcpy(dl_ch1_ext,dl_ch1,12*sizeof(int));
-	      for (i=0;i<12;i++)
-		rxF_ext[i]=rxF[i];
-
-	      dl_ch0_ext+=12;
-	      dl_ch1_ext+=12;
-	      rxF_ext+=12;
-	    }
-	  }
-	  else {
-	    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];
-		  //  		  printf("(skip1,pilots)extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
-		  dl_ch0_ext[j]=dl_ch0[i];
-		  dl_ch1_ext[j++]=dl_ch1[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)];
-		  //  		  printf("(skip2,pilots)extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
-		  dl_ch0_ext[j]=dl_ch0[i+6];
-		  dl_ch1_ext[j++]=dl_ch1[i+6];
-		}
-	      }
-	      dl_ch0_ext+=4;
-	      dl_ch1_ext+=4;
-	      rxF_ext+=4;
-	    }
-	    else {
-	      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];
-		  //	printf("(pilots)extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
-		  dl_ch0_ext[j]=dl_ch0[i];
-		  dl_ch1_ext[j++]=dl_ch1[i];
-		  //			      printf("extract rb %d, re %d => ch0 (%d,%d) ch1 (%d,%d)\n",rb,i,
-		  //				     *(short *)&dl_ch0_ext[j-1],*(1+(short*)&dl_ch0_ext[j-1]),
-		  //				     *(short *)&dl_ch1_ext[j-1],*(1+(short*)&dl_ch1_ext[j-1]));
-		}
-	      }
-	      dl_ch0_ext+=8;
-	      dl_ch1_ext+=8;
-	      rxF_ext+=8;
-	      
-	    }
-	  }
-	  nb_rb++;
-	}
-	dl_ch0+=12;
-	dl_ch1+=12;
-	rxF+=12;
+        skip_half=0;
+        
+        if (rb < 32)
+          rb_alloc_ind = (rb_alloc[0]>>rb) & 1;
+        else if (rb < 64)
+          rb_alloc_ind = (rb_alloc[1]>>(rb-32)) & 1;
+        else if (rb < 96)
+          rb_alloc_ind = (rb_alloc[2]>>(rb-64)) & 1;
+        else if (rb < 100)
+          rb_alloc_ind = (rb_alloc[3]>>(rb-96)) & 1;
+        else
+          rb_alloc_ind = 0;
+        
+        
+        // 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))) {
+          rb_alloc_ind = 0;
+        }
+        //PBCH subframe 0, symbols nsymb>>1 ... nsymb>>1 + 3
+        if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
+          skip_half=1;
+        else if ((subframe==0) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l>=(nsymb>>1)) && (l<((nsymb>>1) + 4)))
+          skip_half=2;
+
+        //SSS
+        if (((subframe==0)||(subframe==5)) && (rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==sss_symb) ) {
+          rb_alloc_ind = 0;
+        }
+        //SSS 
+        if (((subframe==0)||(subframe==5)) && 
+            (rb==((frame_parms->N_RB_DL>>1)-3)) && 
+            (l==sss_symb))
+          skip_half=1;
+        else if (((subframe==0)||(subframe==5)) && 
+                 (rb==((frame_parms->N_RB_DL>>1)+3)) && 
+                 (l==sss_symb))
+          skip_half=2;
+
+        if (frame_parms->frame_type == FDD) {
+          //PSS
+          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_alloc_ind = 0;
+
+          }
+          if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)-3)) && (l==pss_symb))
+            skip_half=1;
+          else if (((subframe==0)||(subframe==5)) && (rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
+            skip_half=2;
+        }
+        
+        if ((frame_parms->frame_type == TDD) &&
+            (subframe==6)){
+          //PSS
+          if ((rb>((frame_parms->N_RB_DL>>1)-3)) && (rb<((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb) ) {
+            rb_alloc_ind = 0;
+          }
+          if ((rb==((frame_parms->N_RB_DL>>1)-3)) && (l==pss_symb))
+            skip_half=1;
+          else if ((rb==((frame_parms->N_RB_DL>>1)+3)) && (l==pss_symb))
+            skip_half=2;
+        }
+        
+        if (rb_alloc_ind==1) {
+          
+          *pmi_loc = (pmi>>((rb>>2)<<1))&3;
+          //      printf("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",rb,rb>>2,*pmi_loc,pmi_loc,rxF,dl_ch0, dl_ch1, rxF_ext,dl_ch0_ext,dl_ch1_ext);
+          
+          pmi_loc++;
+          
+          if (pilots==0) {
+            if (skip_half==1) {
+              memcpy(dl_ch0_ext,dl_ch0,6*sizeof(int));
+              memcpy(dl_ch1_ext,dl_ch1,6*sizeof(int));
+              for (i=0;i<6;i++)
+                rxF_ext[i]=rxF[i];
+              dl_ch0_ext+=6;
+              dl_ch1_ext+=6;
+              rxF_ext+=6;
+              
+            }
+            else if (skip_half==2) {
+              memcpy(dl_ch0_ext,dl_ch0+6,6*sizeof(int));
+              memcpy(dl_ch1_ext,dl_ch1+6,6*sizeof(int));
+              for (i=0;i<6;i++)
+                rxF_ext[i]=rxF[(i+6)];
+              dl_ch0_ext+=6;
+              dl_ch1_ext+=6;
+              rxF_ext+=6;
+              
+            }
+            else {
+              memcpy(dl_ch0_ext,dl_ch0,12*sizeof(int));
+              memcpy(dl_ch1_ext,dl_ch1,12*sizeof(int));
+              for (i=0;i<12;i++)
+                rxF_ext[i]=rxF[i];
+
+              dl_ch0_ext+=12;
+              dl_ch1_ext+=12;
+              rxF_ext+=12;
+            }
+          }
+          else {
+            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];
+                  //              printf("(skip1,pilots)extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  dl_ch0_ext[j]=dl_ch0[i];
+                  dl_ch1_ext[j++]=dl_ch1[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)];
+                  //              printf("(skip2,pilots)extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  dl_ch0_ext[j]=dl_ch0[i+6];
+                  dl_ch1_ext[j++]=dl_ch1[i+6];
+                }
+              }
+              dl_ch0_ext+=4;
+              dl_ch1_ext+=4;
+              rxF_ext+=4;
+            }
+            else {
+              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];
+                  //    printf("(pilots)extract rb %d, re %d => (%d,%d)\n",rb,i,*(short *)&rxF_ext[j],*(1+(short*)&rxF_ext[j]));
+                  dl_ch0_ext[j]=dl_ch0[i];
+                  dl_ch1_ext[j++]=dl_ch1[i];
+                  //                          printf("extract rb %d, re %d => ch0 (%d,%d) ch1 (%d,%d)\n",rb,i,
+                  //                                 *(short *)&dl_ch0_ext[j-1],*(1+(short*)&dl_ch0_ext[j-1]),
+                  //                                 *(short *)&dl_ch1_ext[j-1],*(1+(short*)&dl_ch1_ext[j-1]));
+                }
+              }
+              dl_ch0_ext+=8;
+              dl_ch1_ext+=8;
+              rxF_ext+=8;
+              
+            }
+          }
+          nb_rb++;
+        }
+        dl_ch0+=12;
+        dl_ch1+=12;
+        rxF+=12;
       }
     }
   }
@@ -3329,7 +3655,7 @@ unsigned short dlsch_extract_rbs_dual(int **rxdataF,
 
 #ifdef USER_MODE
 
-void dump_dlsch2(PHY_VARS_UE *phy_vars_ue,uint8_t eNB_id,uint16_t coded_bits_per_codeword,int round) {
+void dump_dlsch2(PHY_VARS_UE *phy_vars_ue,uint8_t eNB_id,uint16_t coded_bits_per_codeword,int round, unsigned char harq_pid ) {
 
   unsigned int nsymb = (phy_vars_ue->lte_frame_parms.Ncp == 0) ? 14 : 12;
   char fname[32],vname[32];
@@ -3368,7 +3694,7 @@ void dump_dlsch2(PHY_VARS_UE *phy_vars_ue,uint8_t eNB_id,uint16_t coded_bits_per
   */
   sprintf(fname,"dlsch%d_r%d_rho.m",eNB_id,round);
   sprintf(vname,"dl_rho_r%d_%d",eNB_id,round);
-  write_output(fname,vname,phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[0],12*N_RB_DL*nsymb,1,1);
+  write_output(fname,vname,phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[0][0][0],12*N_RB_DL*nsymb,1,1);
 
   sprintf(fname,"dlsch%d_rxF_r%d_comp0.m",eNB_id,round);
   sprintf(vname,"dl%d_rxF_r%d_comp0",eNB_id,round);
@@ -3377,7 +3703,7 @@ void dump_dlsch2(PHY_VARS_UE *phy_vars_ue,uint8_t eNB_id,uint16_t coded_bits_per
   if (phy_vars_ue->lte_frame_parms.nb_antennas_tx_eNB == 2) {
     sprintf(fname,"dlsch%d_rxF_r%d_comp1.m",eNB_id,round);
     sprintf(vname,"dl%d_rxF_r%d_comp1",eNB_id,round);
-    write_output(fname,vname,phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[0][round],12*N_RB_DL*nsymb,1,1);
+    write_output(fname,vname,phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[harq_pid][round][0],12*N_RB_DL*nsymb,1,1);
   }
 
   sprintf(fname,"dlsch%d_rxF_r%d_llr.m",eNB_id,round);
diff --git a/openair1/PHY/LTE_TRANSPORT/dlsch_llr_computation.c b/openair1/PHY/LTE_TRANSPORT/dlsch_llr_computation.c
index 7fa6bddcab2..d1ef184e7f8 100644
--- a/openair1/PHY/LTE_TRANSPORT/dlsch_llr_computation.c
+++ b/openair1/PHY/LTE_TRANSPORT/dlsch_llr_computation.c
@@ -642,7 +642,7 @@ int dlsch_qpsk_llr(LTE_DL_FRAME_PARMS *frame_parms,
                    uint16_t pbch_pss_sss_adjust,
                    short **llr32p) {
 
-  uint32_t *rxF = (uint32_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
+  uint32_t *rxF = (uint32_t*)&rxdataF_comp[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
   uint32_t *llr32;
   int i,len;
   uint8_t symbol_mod = (symbol >= (7-frame_parms->Ncp))? (symbol-(7-frame_parms->Ncp)) : symbol;
@@ -698,7 +698,7 @@ void dlsch_16qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
                      uint16_t pbch_pss_sss_adjust,
                      int16_t **llr32p) {
 
-    __m128i *rxF = (__m128i*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
+    __m128i *rxF = (__m128i*)&rxdataF_comp[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
     __m128i *ch_mag;
     __m128i llr128[2];
     int i,len;
@@ -715,7 +715,7 @@ void dlsch_16qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
   
     symbol_mod = (symbol>=(7-frame_parms->Ncp)) ? symbol-(7-frame_parms->Ncp) : symbol;
     
-    ch_mag = (__m128i*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
+    ch_mag = (__m128i*)&dl_ch_mag[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
     
     if ((symbol_mod==0) || (symbol_mod==(4-frame_parms->Ncp))) {
         if (frame_parms->mode1_flag==0)
@@ -774,7 +774,7 @@ void dlsch_64qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
                      uint16_t pbch_pss_sss_adjust,
                      short **llr_save) {
 
-    __m128i *rxF = (__m128i*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
+    __m128i *rxF = (__m128i*)&rxdataF_comp[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
     __m128i *ch_mag,*ch_magb;
     int i,len,len2;
     unsigned char symbol_mod,len_mod4;
@@ -788,8 +788,8 @@ void dlsch_64qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
     
     symbol_mod = (symbol>=(7-frame_parms->Ncp)) ? symbol-(7-frame_parms->Ncp) : symbol;
     
-    ch_mag = (__m128i*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
-    ch_magb = (__m128i*)&dl_ch_magb[0][(symbol*frame_parms->N_RB_DL*12)];
+    ch_mag = (__m128i*)&dl_ch_mag[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    ch_magb = (__m128i*)&dl_ch_magb[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
 
     if ((symbol_mod==0) || (symbol_mod==(4-frame_parms->Ncp))) {
         if (frame_parms->mode1_flag==0)
@@ -902,9 +902,9 @@ int dlsch_qpsk_qpsk_llr(LTE_DL_FRAME_PARMS *frame_parms,
                         uint16_t pbch_pss_sss_adjust,
                         short **llr16p) {
     
-    int16_t *rxF=(int16_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rxF_i=(int16_t*)&rxdataF_comp_i[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rho=(int16_t*)&rho_i[0][(symbol*frame_parms->N_RB_DL*12)];
+    int16_t *rxF=(int16_t*)&rxdataF_comp[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rxF_i=(int16_t*)&rxdataF_comp_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rho=(int16_t*)&rho_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
     int16_t *llr16;
     int len;
     uint8_t symbol_mod = (symbol >= (7-frame_parms->Ncp))? (symbol-(7-frame_parms->Ncp)) : symbol;
@@ -935,7 +935,7 @@ int dlsch_qpsk_qpsk_llr(LTE_DL_FRAME_PARMS *frame_parms,
         len = (nb_rb*12) - pbch_pss_sss_adjust;
     }
 
-    //    printf("qpsk_qpsk: len %d, llr16 %p\n",len,llr16);
+    //printf("qpsk_qpsk: len %d, llr16 %p, rho %p\n",len,llr16,rho);
     qpsk_qpsk((short *)rxF,
               (short *)rxF_i,
               (short *)llr16,
@@ -981,6 +981,7 @@ length = number of resource elements
     ONE_OVER_SQRT_8 = _mm_set1_epi16(23170); //round(2^16/sqrt(8))
 
     for (i=0;i<length>>2;i+=2) {
+      //printf("%d.",i);
         // in each iteration, we take 8 complex samples
 
         xmm0 = rho01_128i[i]; // 4 symbols
@@ -1115,6 +1116,7 @@ length = number of resource elements
 	  _mm_storeu_si128(&stream0_128i_out[i+1],_mm_unpackhi_epi16(y0r,y0i));
 	
     }
+    //printf("\n");
     _mm_empty();
     _m_empty();
 }
@@ -1131,10 +1133,10 @@ int dlsch_qpsk_16qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
                          uint16_t pbch_pss_sss_adjust,
                          short **llr16p) {
     
-    int16_t *rxF=(int16_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rxF_i=(int16_t*)&rxdataF_comp_i[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *ch_mag_i = (int16_t*)&dl_ch_mag_i[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rho=(int16_t*)&rho_i[0][(symbol*frame_parms->N_RB_DL*12)];
+    int16_t *rxF=(int16_t*)&rxdataF_comp[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rxF_i=(int16_t*)&rxdataF_comp_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *ch_mag_i = (int16_t*)&dl_ch_mag_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rho=(int16_t*)&rho_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
     int16_t *llr16;
     int len;
     uint8_t symbol_mod = (symbol >= (7-frame_parms->Ncp))? (symbol-(7-frame_parms->Ncp)) : symbol;
@@ -1390,10 +1392,10 @@ int dlsch_qpsk_64qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
                          uint16_t pbch_pss_sss_adjust,
                          short **llr16p) {
     
-    int16_t *rxF=(int16_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rxF_i=(int16_t*)&rxdataF_comp_i[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *ch_mag_i = (int16_t*)&dl_ch_mag_i[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rho=(int16_t*)&rho_i[0][(symbol*frame_parms->N_RB_DL*12)];
+    int16_t *rxF=(int16_t*)&rxdataF_comp[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rxF_i=(int16_t*)&rxdataF_comp_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *ch_mag_i = (int16_t*)&dl_ch_mag_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rho=(int16_t*)&rho_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
     int16_t *llr16;
     int len;
     uint8_t symbol_mod = (symbol >= (7-frame_parms->Ncp))? (symbol-(7-frame_parms->Ncp)) : symbol;
@@ -2077,10 +2079,10 @@ int dlsch_16qam_qpsk_llr(LTE_DL_FRAME_PARMS *frame_parms,
                          uint16_t pbch_pss_sss_adjust,
                          short **llr16p) {
 
-    int16_t *rxF      = (int16_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rxF_i    = (int16_t*)&rxdataF_comp_i[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *ch_mag   = (int16_t*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rho      = (int16_t*)&rho_i[0][(symbol*frame_parms->N_RB_DL*12)];
+    int16_t *rxF      = (int16_t*)&rxdataF_comp[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rxF_i    = (int16_t*)&rxdataF_comp_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *ch_mag   = (int16_t*)&dl_ch_mag[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rho      = (int16_t*)&rho_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
     int16_t *llr16;
     int len;
     uint8_t symbol_mod = (symbol >= (7-frame_parms->Ncp))? (symbol-(7-frame_parms->Ncp)) : symbol;
@@ -2580,11 +2582,11 @@ int dlsch_16qam_16qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
                           uint16_t pbch_pss_sss_adjust,
                           short **llr16p) {
 
-    int16_t *rxF      = (int16_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rxF_i    = (int16_t*)&rxdataF_comp_i[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *ch_mag   = (int16_t*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *ch_mag_i = (int16_t*)&dl_ch_mag_i[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rho      = (int16_t*)&rho_i[0][(symbol*frame_parms->N_RB_DL*12)];
+    int16_t *rxF      = (int16_t*)&rxdataF_comp[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rxF_i    = (int16_t*)&rxdataF_comp_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *ch_mag   = (int16_t*)&dl_ch_mag[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *ch_mag_i = (int16_t*)&dl_ch_mag_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rho      = (int16_t*)&rho_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
     int16_t *llr16;
     int len;
     uint8_t symbol_mod = (symbol >= (7-frame_parms->Ncp))? (symbol-(7-frame_parms->Ncp)) : symbol;
@@ -3112,11 +3114,11 @@ int dlsch_16qam_64qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
                           uint16_t pbch_pss_sss_adjust,
                           short **llr16p) {
 
-    int16_t *rxF      = (int16_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rxF_i    = (int16_t*)&rxdataF_comp_i[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *ch_mag   = (int16_t*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *ch_mag_i = (int16_t*)&dl_ch_mag_i[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rho      = (int16_t*)&rho_i[0][(symbol*frame_parms->N_RB_DL*12)];
+    int16_t *rxF      = (int16_t*)&rxdataF_comp[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rxF_i    = (int16_t*)&rxdataF_comp_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *ch_mag   = (int16_t*)&dl_ch_mag[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *ch_mag_i = (int16_t*)&dl_ch_mag_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rho      = (int16_t*)&rho_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
     int16_t *llr16;
     int len;
     uint8_t symbol_mod = (symbol >= (7-frame_parms->Ncp))? (symbol-(7-frame_parms->Ncp)) : symbol;
@@ -4456,10 +4458,10 @@ int dlsch_64qam_qpsk_llr(LTE_DL_FRAME_PARMS *frame_parms,
                          uint16_t pbch_pss_sss_adjust,
                          short **llr16p) {
 
-    int16_t *rxF      = (int16_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rxF_i    = (int16_t*)&rxdataF_comp_i[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *ch_mag   = (int16_t*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rho      = (int16_t*)&rho_i[0][(symbol*frame_parms->N_RB_DL*12)];
+    int16_t *rxF      = (int16_t*)&rxdataF_comp[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rxF_i    = (int16_t*)&rxdataF_comp_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *ch_mag   = (int16_t*)&dl_ch_mag[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rho      = (int16_t*)&rho_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
     int16_t *llr16;
     int len;
     uint8_t symbol_mod = (symbol >= (7-frame_parms->Ncp))? (symbol-(7-frame_parms->Ncp)) : symbol;
@@ -5718,11 +5720,11 @@ int dlsch_64qam_16qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
                           uint16_t pbch_pss_sss_adjust,
                           short **llr16p) {
 
-    int16_t *rxF      = (int16_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rxF_i    = (int16_t*)&rxdataF_comp_i[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *ch_mag   = (int16_t*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *ch_mag_i = (int16_t*)&dl_ch_mag_i[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rho      = (int16_t*)&rho_i[0][(symbol*frame_parms->N_RB_DL*12)];
+    int16_t *rxF      = (int16_t*)&rxdataF_comp[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rxF_i    = (int16_t*)&rxdataF_comp_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *ch_mag   = (int16_t*)&dl_ch_mag[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *ch_mag_i = (int16_t*)&dl_ch_mag_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rho      = (int16_t*)&rho_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
     int16_t *llr16;
     int len;
     uint8_t symbol_mod = (symbol >= (7-frame_parms->Ncp))? (symbol-(7-frame_parms->Ncp)) : symbol;
@@ -7108,11 +7110,11 @@ int dlsch_64qam_64qam_llr(LTE_DL_FRAME_PARMS *frame_parms,
                           uint16_t pbch_pss_sss_adjust,
                           short **llr16p) {
 
-    int16_t *rxF      = (int16_t*)&rxdataF_comp[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rxF_i    = (int16_t*)&rxdataF_comp_i[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *ch_mag   = (int16_t*)&dl_ch_mag[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *ch_mag_i = (int16_t*)&dl_ch_mag_i[0][(symbol*frame_parms->N_RB_DL*12)];
-    int16_t *rho      = (int16_t*)&rho_i[0][(symbol*frame_parms->N_RB_DL*12)];
+    int16_t *rxF      = (int16_t*)&rxdataF_comp[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rxF_i    = (int16_t*)&rxdataF_comp_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *ch_mag   = (int16_t*)&dl_ch_mag[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *ch_mag_i = (int16_t*)&dl_ch_mag_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
+    int16_t *rho      = (int16_t*)&rho_i[0][(((int)symbol)*((int)frame_parms->N_RB_DL)*12)];
     int16_t *llr16;
     int len;
     uint8_t symbol_mod = (symbol >= (7-frame_parms->Ncp))? (symbol-(7-frame_parms->Ncp)) : symbol;
diff --git a/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c b/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c
index 6e4c7803d48..15b5db72e87 100644
--- a/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c
+++ b/openair1/PHY/LTE_TRANSPORT/dlsch_modulation.c
@@ -155,15 +155,14 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
   int first_layer0        = dlsch0_harq->first_layer;
   int Nlayers0            = dlsch0_harq->Nlayers; 
   uint8_t mod_order0      = get_Qm(dlsch0_harq->mcs);
-
+  uint8_t mod_order1=2;
+  uint8_t precoder_index0,precoder_index1;
 
   uint8_t *x1=NULL;
-  uint8_t mod_order1=2;
   // Fill these in later for TM8-10
   //  int Nlayers1;
   //  int first_layer1;
 
-
   int use2ndpilots = (frame_parms->mode1_flag==1)?1:0;
 
   uint32_t tti_offset,aa;
@@ -642,7 +641,7 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
 	}
       }
       else if ((mimo_mode >= UNIFORM_PRECODING11)&&(mimo_mode <= PUSCH_PRECODING1)) {
-	// this is for transmission modes 4-6 (1 layer)
+	// this is for transmission modes 5-6 (1 layer)
 	*re_allocated = *re_allocated + 1;	         
 	amp = (int16_t)(((int32_t)tmp_amp*ONE_OVER_SQRT2_Q15)>>15);
 
@@ -740,6 +739,214 @@ int allocate_REs_in_RB(LTE_DL_FRAME_PARMS *frame_parms,
 	  
 	}
       }
+      else if ((mimo_mode >= DUALSTREAM_UNIFORM_PRECODING1)&&(mimo_mode <= DUALSTREAM_PUSCH_PRECODING)) {
+	// this is for transmission mode 4 (1 layer)
+	*re_allocated = *re_allocated + 1;	         
+	//amp = (int16_t)(((int32_t)tmp_amp*ONE_OVER_SQRT2_Q15)>>15);
+	amp = tmp_amp/2;
+	gain_lin_QPSK = (int16_t)((amp*ONE_OVER_SQRT2_Q15)>>15);
+
+	if (precoder_index==0) {
+	  precoder_index0 = 0; //[1 1]
+	  precoder_index1 = 1; //[1 -1]
+	}
+	else if (precoder_index==1) {
+	  precoder_index0 = 2; //[1 j]
+	  precoder_index1 = 3; //[1 -j]
+	}
+	else {
+	  LOG_E(PHY,"problem with precoder in TM4\n");
+	  return(-1);
+	}
+
+	switch (mod_order0) {
+	case 2:  //QPSK
+
+	  ((int16_t*)&tmp_sample1)[0] = (x0[*jj]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK;
+	  *jj = *jj + 1;
+	  ((int16_t*)&tmp_sample1)[1] = (x0[*jj]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK;
+	  *jj = *jj + 1;
+
+      // normalization for 2 tx antennas
+	  ((int16_t*)&txdataF[0][tti_offset])[0] += ((int16_t*)&tmp_sample1)[0];
+	  ((int16_t*)&txdataF[0][tti_offset])[1] += ((int16_t*)&tmp_sample1)[1];
+
+	  if (frame_parms->nb_antennas_tx == 2) {
+	    layer1prec2A(&tmp_sample1,&tmp_sample2,precoder_index0);
+	    ((int16_t*)&txdataF[1][tti_offset])[0] += ((int16_t*)&tmp_sample2)[0];
+	    ((int16_t*)&txdataF[1][tti_offset])[1] += ((int16_t*)&tmp_sample2)[1];
+	  }
+
+	  break;
+	  
+	case 4:  //16QAM
+	  
+	  qam16_table_offset_re = 0;
+	  qam16_table_offset_im = 0;
+
+	  if (x0[*jj] == 1)
+	    qam16_table_offset_re+=2;
+	  *jj=*jj+1;
+	  if (x0[*jj] == 1)
+	    qam16_table_offset_im+=2;
+	  *jj=*jj+1;
+	  
+	  
+	  if (x0[*jj] == 1)
+	    qam16_table_offset_re+=1;
+	  *jj=*jj+1;
+	  if (x0[*jj] == 1)
+	    qam16_table_offset_im+=1;
+	  *jj=*jj+1;
+	  
+	   ((int16_t*)&tmp_sample1)[0] = (int16_t)(((int32_t)amp*qam16_table[qam16_table_offset_re])>>15);
+	   ((int16_t*)&tmp_sample1)[1] = (int16_t)(((int32_t)amp*qam16_table[qam16_table_offset_im])>>15);
+
+	   ((int16_t *)&txdataF[0][tti_offset])[0] += ((int16_t*)&tmp_sample1)[0];
+	   ((int16_t *)&txdataF[0][tti_offset])[1] += ((int16_t*)&tmp_sample1)[1];
+	  
+	  if (frame_parms->nb_antennas_tx == 2) {
+	    layer1prec2A(&tmp_sample1,&tmp_sample2,precoder_index0);
+	    ((int16_t*)&txdataF[1][tti_offset])[0] += ((int16_t*)&tmp_sample2)[0];
+	    ((int16_t*)&txdataF[1][tti_offset])[1] += ((int16_t*)&tmp_sample2)[1];
+	  }
+
+	  break;
+	  
+	case 6:  //64QAM
+	  
+	  
+	  qam64_table_offset_re = 0;
+	  qam64_table_offset_im = 0;
+	  if (x0[*jj] == 1)
+	    qam64_table_offset_re+=4;
+	  *jj=*jj+1;
+	  if (x0[*jj] == 1)
+	    qam64_table_offset_im+=4;
+	  *jj=*jj+1;
+	  if (x0[*jj] == 1)
+	    qam64_table_offset_re+=2;
+	  *jj=*jj+1;
+	  if (x0[*jj] == 1)
+	    qam64_table_offset_im+=2;
+	  *jj=*jj+1;
+	  if (x0[*jj] == 1)
+	    qam64_table_offset_re+=1;
+	  *jj=*jj+1;
+	  if (x0[*jj] == 1)
+	    qam64_table_offset_im+=1;
+	  *jj=*jj+1;
+	  
+	  ((int16_t*)&tmp_sample1)[0] = (int16_t)(((int32_t)amp*qam64_table[qam64_table_offset_re])>>15);
+	  ((int16_t*)&tmp_sample1)[1] = (int16_t)(((int32_t)amp*qam64_table[qam64_table_offset_im])>>15);
+
+	  ((int16_t *)&txdataF[0][tti_offset])[0] += ((int16_t*)&tmp_sample1)[0];
+	  ((int16_t *)&txdataF[0][tti_offset])[1] += ((int16_t*)&tmp_sample1)[1];
+	  
+	  if (frame_parms->nb_antennas_tx == 2) {
+	    layer1prec2A(&tmp_sample1,&tmp_sample2,precoder_index0);
+	    ((int16_t*)&txdataF[1][tti_offset])[0] += ((int16_t*)&tmp_sample2)[0];
+	    ((int16_t*)&txdataF[1][tti_offset])[1] += ((int16_t*)&tmp_sample2)[1];
+	  }
+	  
+	  break;
+	  
+	}
+	switch (mod_order1) {
+	case 2:  //QPSK
+
+	  ((int16_t*)&tmp_sample1)[0] = (x1[*jj2]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK;
+	  *jj2 = *jj2 + 1;
+	  ((int16_t*)&tmp_sample1)[1] = (x1[*jj2]==1) ? (-gain_lin_QPSK) : gain_lin_QPSK;
+	  *jj2 = *jj2 + 1;
+
+      // normalization for 2 tx antennas
+	  ((int16_t*)&txdataF[0][tti_offset])[0] += ((int16_t*)&tmp_sample1)[0];
+	  ((int16_t*)&txdataF[0][tti_offset])[1] += ((int16_t*)&tmp_sample1)[1];
+
+	  if (frame_parms->nb_antennas_tx == 2) {
+	    layer1prec2A(&tmp_sample1,&tmp_sample2,precoder_index1);
+	    ((int16_t*)&txdataF[1][tti_offset])[0] += ((int16_t*)&tmp_sample2)[0];
+	    ((int16_t*)&txdataF[1][tti_offset])[1] += ((int16_t*)&tmp_sample2)[1];
+	  }
+
+	  break;
+	  
+	case 4:  //16QAM
+	  
+	  qam16_table_offset_re = 0;
+	  qam16_table_offset_im = 0;
+
+	  if (x1[*jj2] == 1)
+	    qam16_table_offset_re+=2;
+	  *jj2=*jj2+1;
+	  if (x1[*jj2] == 1)
+	    qam16_table_offset_im+=2;
+	  *jj2=*jj2+1;
+	  
+	  
+	  if (x1[*jj2] == 1)
+	    qam16_table_offset_re+=1;
+	  *jj2=*jj2+1;
+	  if (x1[*jj2] == 1)
+	    qam16_table_offset_im+=1;
+	  *jj2=*jj2+1;
+	  
+	   ((int16_t*)&tmp_sample1)[0] = (int16_t)(((int32_t)amp*qam16_table[qam16_table_offset_re])>>15);
+	   ((int16_t*)&tmp_sample1)[1] = (int16_t)(((int32_t)amp*qam16_table[qam16_table_offset_im])>>15);
+
+	   ((int16_t *)&txdataF[0][tti_offset])[0] += ((int16_t*)&tmp_sample1)[0];
+	   ((int16_t *)&txdataF[0][tti_offset])[1] += ((int16_t*)&tmp_sample1)[1];
+	  
+	  if (frame_parms->nb_antennas_tx == 2) {
+	    layer1prec2A(&tmp_sample1,&tmp_sample2,precoder_index1);
+	    ((int16_t*)&txdataF[1][tti_offset])[0] += ((int16_t*)&tmp_sample2)[0];
+	    ((int16_t*)&txdataF[1][tti_offset])[1] += ((int16_t*)&tmp_sample2)[1];
+	  }
+
+	  break;
+	  
+	case 6:  //64QAM
+	  
+	  
+	  qam64_table_offset_re = 0;
+	  qam64_table_offset_im = 0;
+	  if (x1[*jj2] == 1)
+	    qam64_table_offset_re+=4;
+	  *jj2=*jj2+1;
+	  if (x1[*jj2] == 1)
+	    qam64_table_offset_im+=4;
+	  *jj2=*jj2+1;
+	  if (x1[*jj2] == 1)
+	    qam64_table_offset_re+=2;
+	  *jj2=*jj2+1;
+	  if (x1[*jj2] == 1)
+	    qam64_table_offset_im+=2;
+	  *jj2=*jj2+1;
+	  if (x1[*jj2] == 1)
+	    qam64_table_offset_re+=1;
+	  *jj2=*jj2+1;
+	  if (x1[*jj2] == 1)
+	    qam64_table_offset_im+=1;
+	  *jj2=*jj2+1;
+	  
+	  ((int16_t*)&tmp_sample1)[0] = (int16_t)(((int32_t)amp*qam64_table[qam64_table_offset_re])>>15);
+	  ((int16_t*)&tmp_sample1)[1] = (int16_t)(((int32_t)amp*qam64_table[qam64_table_offset_im])>>15);
+
+	  ((int16_t *)&txdataF[0][tti_offset])[0] += ((int16_t*)&tmp_sample1)[0];
+	  ((int16_t *)&txdataF[0][tti_offset])[1] += ((int16_t*)&tmp_sample1)[1];
+	  
+	  if (frame_parms->nb_antennas_tx == 2) {
+	    layer1prec2A(&tmp_sample1,&tmp_sample2,precoder_index1);
+	    ((int16_t*)&txdataF[1][tti_offset])[0] += ((int16_t*)&tmp_sample2)[0];
+	    ((int16_t*)&txdataF[1][tti_offset])[1] += ((int16_t*)&tmp_sample2)[1];
+	  }
+	  
+	  break;
+	  
+	}
+      }
+
       if (mimo_mode == ALAMOUTI) {
 	re++;  // adjacent carriers are taken care of by precoding
 	*re_allocated = *re_allocated + 1;
diff --git a/openair1/PHY/LTE_TRANSPORT/power_control.c b/openair1/PHY/LTE_TRANSPORT/power_control.c
index 5f7ffe1e2f3..14f46147210 100644
--- a/openair1/PHY/LTE_TRANSPORT/power_control.c
+++ b/openair1/PHY/LTE_TRANSPORT/power_control.c
@@ -36,24 +36,27 @@ 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},
+double ratioPB[2][4]={{ 0.00000,  -0.96910,  -2.21849,  -3.97940}, //in db
 		      { 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};
+double pa_values[8]={-6.0,-4.77,-3.0,-1.77,0.0,1.0,2.0,3.0}; //reported by higher layers
 
 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){		    	
+                       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_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));	
 	
@@ -75,7 +78,7 @@ 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);
+  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;
@@ -95,7 +98,9 @@ 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){		    	
+                      unsigned char dl_power_off, 
+		      uint8_t n_antenna_port
+ 		    ){		    	
     
   double rho_a_dB;
   double sqrt_rho_a_lin;
@@ -103,7 +108,11 @@ double computeRhoA_UE(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated,
   rho_a_dB = pa_values[ pdsch_config_dedicated->p_a];
 	
   if(!dl_power_off) 
-    rho_a_dB-=10*log10(2);
+    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));	
 	
@@ -125,7 +134,7 @@ 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);
+  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;
diff --git a/openair1/PHY/LTE_TRANSPORT/proto.h b/openair1/PHY/LTE_TRANSPORT/proto.h
index e60b6abfe86..7b58cd701e6 100644
--- a/openair1/PHY/LTE_TRANSPORT/proto.h
+++ b/openair1/PHY/LTE_TRANSPORT/proto.h
@@ -145,7 +145,7 @@ void dlsch_encoding_emul(PHY_VARS_eNB *phy_vars_eNB,
     \brief Fills RB with data
     \param txdataF pointer to output data (frequency domain signal)
     \param jj index to output (from CW 1)
-    \param jj index to output (from CW 2)
+    \param jj2 index to output (from CW 2)
     \param re_offset index of the first RE of the RB
     \param symbol_offset index to the OFDM symbol
     \param dlsch0_harq Pointer to Transport block 0 HARQ structure
@@ -833,6 +833,14 @@ void dlsch_detection_mrc(LTE_DL_FRAME_PARMS *frame_parms,
 			 uint16_t nb_rb,
 			 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);
+
 /** \fn dlsch_extract_rbs_single(int32_t **rxdataF,
     int32_t **dl_ch_estimates,
     int32_t **rxdataF_ext,
@@ -956,14 +964,16 @@ void dlsch_channel_compensation_TM56(int **rxdataF_ext,
 				     unsigned char output_shift,
 				     unsigned char dl_power_off);
 
-void dlsch_channel_compensation_TM3(LTE_DL_FRAME_PARMS *frame_parms,
+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_shift);
 
@@ -981,11 +991,12 @@ void dlsch_channel_level(int32_t **dl_ch_estimates_ext,
 			 uint8_t pilots_flag,
 			 uint16_t nb_rb);
 
-void dlsch_channel_level_TM3(int **dl_ch_estimates_ext,
-			     LTE_DL_FRAME_PARMS *frame_parms,
-			     int *avg,
-			     uint8_t symbol,
-			     unsigned short nb_rb);
+void dlsch_channel_level_TM34(int **dl_ch_estimates_ext,
+			      LTE_DL_FRAME_PARMS *frame_parms,
+			      int *avg,
+			      uint8_t symbol,
+			      unsigned short nb_rb,
+			      MIMO_mode_t mimo_mode);
 
 void dlsch_channel_level_TM56(int32_t **dl_ch_estimates_ext,
                               LTE_DL_FRAME_PARMS *frame_parms,
@@ -1038,6 +1049,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. 
     @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
@@ -1045,7 +1057,7 @@ 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 dual_stream_UE Flag to indicate dual-stream interference cancellation
+    @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,
@@ -1055,7 +1067,7 @@ int32_t rx_pdsch(PHY_VARS_UE *phy_vars_ue,
 	     uint8_t subframe,
 	     uint8_t symbol,
 	     uint8_t first_symbol_flag,
-	     uint8_t dual_stream_UE,
+	     RX_type_t rx_type,
 	     uint8_t i_mod,
 	     uint8_t harq_pid);
 
@@ -1407,7 +1419,7 @@ void dump_dlsch(PHY_VARS_UE *phy_vars_ue,uint8_t eNB_id,uint8_t subframe,uint8_t
 void dump_dlsch_SI(PHY_VARS_UE *phy_vars_ue,uint8_t eNB_id,uint8_t subframe);
 void dump_dlsch_ra(PHY_VARS_UE *phy_vars_ue,uint8_t eNB_id,uint8_t subframe);
 
-void dump_dlsch2(PHY_VARS_UE *phy_vars_ue,uint8_t eNB_id,uint16_t coded_bits_per_codeword,int round);
+void dump_dlsch2(PHY_VARS_UE *phy_vars_ue,uint8_t eNB_id,uint16_t coded_bits_per_codeword,int round,uint8_t harq_pid );
 #endif
 
 int dump_dci(LTE_DL_FRAME_PARMS *frame_parms, DCI_ALLOC_t *dci);
@@ -1740,7 +1752,8 @@ 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);
+		       int dl_power_off, 
+		       uint8_t n_antenna_port);
 
 double computeRhoB_eNB(PDSCH_CONFIG_DEDICATED  *pdsch_config_dedicated,
                        PDSCH_CONFIG_COMMON *pdsch_config_common,
@@ -1749,7 +1762,8 @@ double computeRhoB_eNB(PDSCH_CONFIG_DEDICATED  *pdsch_config_dedicated,
 
 double computeRhoA_UE(PDSCH_CONFIG_DEDICATED *pdsch_config_dedicated,  
                       LTE_UE_DLSCH_t *dlsch_ue,
-                      uint8_t dl_power_off);
+                      uint8_t dl_power_off,
+		      uint8_t n_antenna_port);
 
 double computeRhoB_UE(PDSCH_CONFIG_DEDICATED  *pdsch_config_dedicated,
                       PDSCH_CONFIG_COMMON *pdsch_config_common,
diff --git a/openair1/PHY/TOOLS/lte_phy_scope.c b/openair1/PHY/TOOLS/lte_phy_scope.c
index 3fb0f8244c8..3ba28927060 100644
--- a/openair1/PHY/TOOLS/lte_phy_scope.c
+++ b/openair1/PHY/TOOLS/lte_phy_scope.c
@@ -319,10 +319,10 @@ FD_lte_phy_scope_ue *create_lte_phy_scope_ue( void ) {
     FD_lte_phy_scope_ue *fdui = fl_malloc( sizeof *fdui );
     
     // Define form
-    fdui->lte_phy_scope_ue = fl_bgn_form( FL_NO_BOX, 800, 900 );
+    fdui->lte_phy_scope_ue = fl_bgn_form( FL_NO_BOX, 800, 1000 );
 
     // This the whole UI box
-    obj = fl_add_box( FL_BORDER_BOX, 0, 0, 800, 900, "" );
+    obj = fl_add_box( FL_BORDER_BOX, 0, 0, 800, 1000, "" );
     fl_set_object_color( obj, FL_BLACK, FL_BLACK );
 
     // Received signal
@@ -345,6 +345,7 @@ FD_lte_phy_scope_ue *create_lte_phy_scope_ue( void ) {
     fl_set_object_lcolor( fdui->chest_f, FL_WHITE ); // Label color
     fl_set_xyplot_ybounds( fdui->chest_f,30,70);
 
+    /*
     // LLR of PBCH
     fdui->pbch_llr = fl_add_xyplot( FL_POINTS_XYPLOT, 20, 260, 500, 100, "PBCH Log-Likelihood Ratios (LLR, mag)" );
     fl_set_object_boxtype( fdui->pbch_llr, FL_EMBOSSED_BOX );
@@ -377,9 +378,11 @@ FD_lte_phy_scope_ue *create_lte_phy_scope_ue( void ) {
     fl_set_object_lcolor( fdui->pdcch_comp, FL_WHITE ); // Label color
     fl_set_xyplot_symbolsize( fdui->pdcch_comp,2);
     fl_set_xyplot_xgrid( fdui->pdcch_llr,FL_GRID_MAJOR);
+    */
 
+    int offset=240;
     // LLR of PDSCH
-    fdui->pdsch_llr = fl_add_xyplot( FL_POINTS_XYPLOT, 20, 500, 500, 200, "PDSCH Log-Likelihood Ratios (LLR, mag)" );
+    fdui->pdsch_llr = fl_add_xyplot( FL_POINTS_XYPLOT, 20, 500-offset, 500, 200, "PDSCH Log-Likelihood Ratios (LLR, mag)" );
     fl_set_object_boxtype( fdui->pdsch_llr, FL_EMBOSSED_BOX );
     fl_set_object_color( fdui->pdsch_llr, FL_BLACK, FL_YELLOW );
     fl_set_object_lcolor( fdui->pdsch_llr, FL_WHITE ); // Label color
@@ -387,12 +390,28 @@ FD_lte_phy_scope_ue *create_lte_phy_scope_ue( void ) {
     fl_set_xyplot_xgrid( fdui->pdsch_llr,FL_GRID_MAJOR);
 
     // I/Q PDSCH comp
-    fdui->pdsch_comp = fl_add_xyplot( FL_POINTS_XYPLOT, 540, 500, 240, 200, "PDSCH I/Q of MF Output" );
+    fdui->pdsch_comp = fl_add_xyplot( FL_POINTS_XYPLOT, 540, 500-offset, 240, 200, "PDSCH I/Q of MF Output" );
     fl_set_object_boxtype( fdui->pdsch_comp, FL_EMBOSSED_BOX );
     fl_set_object_color( fdui->pdsch_comp, FL_BLACK, FL_YELLOW );
     fl_set_object_lcolor( fdui->pdsch_comp, FL_WHITE ); // Label color
     fl_set_xyplot_symbolsize( fdui->pdsch_comp,2);
-    
+
+    // LLR of PDSCH
+    fdui->pdsch_llr1 = fl_add_xyplot( FL_POINTS_XYPLOT, 20, 720-offset, 500, 200, "PDSCH Log-Likelihood Ratios (LLR, mag)" );
+    fl_set_object_boxtype( fdui->pdsch_llr1, FL_EMBOSSED_BOX );
+    fl_set_object_color( fdui->pdsch_llr1, FL_BLACK, FL_YELLOW );
+    fl_set_object_lcolor( fdui->pdsch_llr1, FL_WHITE ); // Label color
+    fl_set_xyplot_symbolsize( fdui->pdsch_llr1,2);    
+    fl_set_xyplot_xgrid( fdui->pdsch_llr1,FL_GRID_MAJOR);
+
+    // I/Q PDSCH comp
+    fdui->pdsch_comp1 = fl_add_xyplot( FL_POINTS_XYPLOT, 540, 720-offset, 240, 200, "PDSCH I/Q of MF Output" );
+    fl_set_object_boxtype( fdui->pdsch_comp1, FL_EMBOSSED_BOX );
+    fl_set_object_color( fdui->pdsch_comp1, FL_BLACK, FL_YELLOW );
+    fl_set_object_lcolor( fdui->pdsch_comp1, FL_WHITE ); // Label color
+    fl_set_xyplot_symbolsize( fdui->pdsch_comp1,2);
+
+    /*    
     // Throughput on PDSCH
     fdui->pdsch_tput = fl_add_xyplot( FL_NORMAL_XYPLOT, 20, 720, 500, 100, "PDSCH Throughput [frame]/[kbit/s]" );
     fl_set_object_boxtype( fdui->pdsch_tput, FL_EMBOSSED_BOX );
@@ -408,6 +427,7 @@ FD_lte_phy_scope_ue *create_lte_phy_scope_ue( void ) {
     fl_set_object_color(fdui->button_0, FL_RED, FL_RED);  
     fl_set_object_callback(fdui->button_0, ia_receiver_on_off, 0 );
     fl_hide_object(fdui->button_0);
+    */
 
     fl_end_form( );
     fdui->lte_phy_scope_ue->fdui = fdui;
@@ -428,8 +448,9 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
     int16_t **rxsig_t;
     int16_t **chest_t;
     int16_t **chest_f;
-    int16_t *pdsch_llr;
-    int16_t *pdsch_comp;
+    int16_t *pdsch_llr,*pdsch_llr1;
+    int16_t *pdsch_comp,*pdsch_comp1;
+    int16_t *pdsch_mag0,*pdsch_mag1,*pdsch_magb0,*pdsch_magb1;
     int8_t *pdcch_llr;
     int16_t *pdcch_comp;
     int8_t *pbch_llr;
@@ -444,19 +465,20 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
     float freq[nsymb_ce*nb_antennas_rx*nb_antennas_tx];
     int frame = phy_vars_ue->frame_rx;
     uint32_t total_dlsch_bitrate = phy_vars_ue->bitrate[eNB_id];
-    int coded_bits_per_codeword = 0;
-    int mcs = 0;
+    int coded_bits_per_codeword=0,coded_bits_per_codeword1=1;
+    int mod,mod1;
     unsigned char harq_pid = 0;
     if (phy_vars_ue->dlsch_ue[eNB_id][0]!=NULL) {
         harq_pid = phy_vars_ue->dlsch_ue[eNB_id][0]->current_harq_pid;
 	if (harq_pid>=8)
 	  return;
-        mcs = phy_vars_ue->dlsch_ue[eNB_id][0]->harq_processes[harq_pid]->mcs;    
         // Button 0
+	/*
         if(!phy_vars_ue->dlsch_ue[eNB_id][0]->harq_processes[harq_pid]->dl_power_off) {
             // we are in TM5
             fl_show_object(form->button_0);
         } 
+	*/
     }        
     
     if (phy_vars_ue->lte_ue_pdcch_vars[eNB_id]!=NULL) {
@@ -465,16 +487,32 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
 
     //    coded_bits_per_codeword = frame_parms->N_RB_DL*12*get_Qm(mcs)*(frame_parms->symbols_per_tti);
     if (phy_vars_ue->dlsch_ue[eNB_id][0]!=NULL) {
-        coded_bits_per_codeword = get_G(frame_parms,
-                                        phy_vars_ue->dlsch_ue[eNB_id][0]->harq_processes[harq_pid]->nb_rb,
-                                        phy_vars_ue->dlsch_ue[eNB_id][0]->harq_processes[harq_pid]->rb_alloc,
-                                        get_Qm(mcs),
-					phy_vars_ue->dlsch_ue[eNB_id][0]->harq_processes[harq_pid]->Nl,
-                                        num_pdcch_symbols,
-                                        frame,
-                                        subframe);
+      mod = get_Qm(phy_vars_ue->dlsch_ue[eNB_id][0]->harq_processes[harq_pid]->mcs);
+      coded_bits_per_codeword = get_G(frame_parms,
+				      phy_vars_ue->dlsch_ue[eNB_id][0]->harq_processes[harq_pid]->nb_rb,
+				      phy_vars_ue->dlsch_ue[eNB_id][0]->harq_processes[harq_pid]->rb_alloc,
+				      get_Qm(phy_vars_ue->dlsch_ue[eNB_id][0]->harq_processes[harq_pid]->mcs),
+				      phy_vars_ue->dlsch_ue[eNB_id][0]->harq_processes[harq_pid]->Nl,
+				      num_pdcch_symbols,
+				      frame,
+				      subframe);
     } else {
       coded_bits_per_codeword = 0; //frame_parms->N_RB_DL*12*get_Qm(mcs)*(frame_parms->symbols_per_tti);
+      mod=0;
+    }
+    if (phy_vars_ue->dlsch_ue[eNB_id][1]!=NULL) {
+      mod1 = get_Qm(phy_vars_ue->dlsch_ue[eNB_id][1]->harq_processes[harq_pid]->mcs);
+      coded_bits_per_codeword1 = get_G(frame_parms,
+				       phy_vars_ue->dlsch_ue[eNB_id][1]->harq_processes[harq_pid]->nb_rb,
+				       phy_vars_ue->dlsch_ue[eNB_id][1]->harq_processes[harq_pid]->rb_alloc,
+				       get_Qm(phy_vars_ue->dlsch_ue[eNB_id][1]->harq_processes[harq_pid]->mcs),
+				       phy_vars_ue->dlsch_ue[eNB_id][1]->harq_processes[harq_pid]->Nl,
+				       num_pdcch_symbols,
+				       frame,
+				       subframe);
+    } else {
+      coded_bits_per_codeword1 = 0; //frame_parms->N_RB_DL*12*get_Qm(mcs)*(frame_parms->symbols_per_tti);
+      mod1=0;
     }
     
     I = (float*) calloc(nsymb_ce*2,sizeof(float));
@@ -497,9 +535,19 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
     pdcch_llr = (int8_t*) phy_vars_ue->lte_ue_pdcch_vars[eNB_id]->llr;
     pdcch_comp = (int16_t*) phy_vars_ue->lte_ue_pdcch_vars[eNB_id]->rxdataF_comp[0];
     pdsch_llr = (int16_t*) phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->llr[0]; // stream 0
-    //    pdsch_llr = (int16_t*) phy_vars_ue->lte_ue_pdsch_vars_SI[eNB_id]->llr[0]; // stream 0
+    pdsch_llr1 = (int16_t*) phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->llr[1]; // stream 1
     pdsch_comp = (int16_t*) phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp0[0];
+    //pdsch_comp = (int16_t*) phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->rxdataF_ext[0];
+    //pdsch_comp1 = (int16_t*) phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->rxdataF_ext[1];
+    pdsch_comp1 = (int16_t*) (phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1[0][0])[0];
+    //pdsch_comp1 = (int16_t*) (phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->dl_ch_rho_ext[0][0])[0];
+    pdsch_mag0 = (int16_t*) phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->dl_ch_mag0[0];
+    pdsch_mag1 = (int16_t*) phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1[0];
+    pdsch_magb0 = (int16_t*) phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->dl_ch_magb0[0];
+    pdsch_magb1 = (int16_t*) phy_vars_ue->lte_ue_pdsch_vars[eNB_id]->dl_ch_magb1[0];
     
+    fl_freeze_form(form);
+
     // Received signal in time domain of receive antenna 0
     if (rxsig_t != NULL) { 
         if (rxsig_t[0] != NULL) { 
@@ -590,6 +638,7 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
         }
     }
 
+    /*
     // PBCH LLRs
     if (pbch_llr != NULL) {
         for (i=0; i<1920;i++) {
@@ -630,16 +679,17 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
         
         fl_set_xyplot_data(form->pdcch_comp,I,Q,12*frame_parms->N_RB_DL*num_pdcch_symbols,"","","");
     }
+    */
 
     // PDSCH LLRs
     if (pdsch_llr != NULL) {
-        for (i=0; i<coded_bits_per_codeword/4; i++) {
-            llr[i] = (float) pdsch_llr[4*i];
+        for (i=0; i<coded_bits_per_codeword/mod; i++) {
+            llr[i] = (float) pdsch_llr[mod*i];
             bit[i] = (float) i;
         }
 
-        fl_set_xyplot_xbounds(form->pdsch_llr,0,coded_bits_per_codeword/4);        
-        fl_set_xyplot_data(form->pdsch_llr,bit,llr,coded_bits_per_codeword/4,"","","");
+        fl_set_xyplot_xbounds(form->pdsch_llr,0,coded_bits_per_codeword/mod);        
+        fl_set_xyplot_data(form->pdsch_llr,bit,llr,coded_bits_per_codeword/mod,"","","");
     }
     
     // PDSCH I/Q of MF Output
@@ -654,7 +704,116 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
         }
         fl_set_xyplot_data(form->pdsch_comp,I,Q,ind,"","","");
     }
+
+    if (pdsch_mag0 != NULL) {
+        ind=0;
+        for (k=0; k<frame_parms->symbols_per_tti; k++) {
+            for (i=0; i<12*frame_parms->N_RB_DL/2; i++) {
+	      I[ind] = pdsch_mag0[(2*frame_parms->N_RB_DL*12*k)+4*i]*cos(i*2*M_PI/(12*frame_parms->N_RB_DL/2));
+	      Q[ind] = pdsch_mag0[(2*frame_parms->N_RB_DL*12*k)+4*i+1]*sin(i*2*M_PI/(12*frame_parms->N_RB_DL/2));
+	      ind++;
+            }
+        }
+        fl_add_xyplot_overlay(form->pdsch_comp,1,I,Q,ind,FL_GREEN);
+    }
+    if (pdsch_magb0 != NULL) {
+        ind=0;
+        for (k=0; k<frame_parms->symbols_per_tti; k++) {
+            for (i=0; i<12*frame_parms->N_RB_DL/2; i++) {
+	      I[ind] = pdsch_magb0[(2*frame_parms->N_RB_DL*12*k)+4*i]*cos(i*2*M_PI/(12*frame_parms->N_RB_DL/2));
+	      Q[ind] = pdsch_magb0[(2*frame_parms->N_RB_DL*12*k)+4*i+1]*sin(i*2*M_PI/(12*frame_parms->N_RB_DL/2));
+	      ind++;
+            }
+        }
+        fl_add_xyplot_overlay(form->pdsch_comp,2,I,Q,ind,FL_RED);
+    }
+    if ((pdsch_mag0 != NULL) && (pdsch_magb0 != NULL)) {
+        ind=0;
+        for (k=0; k<frame_parms->symbols_per_tti; k++) {
+            for (i=0; i<12*frame_parms->N_RB_DL/2; i++) {
+	      I[ind] = 
+		(pdsch_mag0[(2*frame_parms->N_RB_DL*12*k)+4*i]+
+		 pdsch_magb0[(2*frame_parms->N_RB_DL*12*k)+4*i])*
+		cos(i*2*M_PI/(12*frame_parms->N_RB_DL/2));
+	      Q[ind] = 
+		(pdsch_mag0[(2*frame_parms->N_RB_DL*12*k)+4*i+1]+
+		 pdsch_magb0[(2*frame_parms->N_RB_DL*12*k)+4*i+1])*
+		sin(i*2*M_PI/(12*frame_parms->N_RB_DL/2));
+	      ind++;
+            }
+        }
+        fl_add_xyplot_overlay(form->pdsch_comp,3,I,Q,ind,FL_BLUE);
+    }
+ 
+
+    // PDSCH LLRs
+    if (pdsch_llr1 != NULL) {
+        for (i=0; i<coded_bits_per_codeword1/mod1; i++) {
+            llr[i] = (float) pdsch_llr1[mod1*i];
+            bit[i] = (float) i;
+        }
+
+        fl_set_xyplot_xbounds(form->pdsch_llr1,0,coded_bits_per_codeword1/mod1);        
+        fl_set_xyplot_data(form->pdsch_llr1,bit,llr,coded_bits_per_codeword1/mod1,"","","");
+    }
     
+    // PDSCH I/Q of MF Output
+    if (pdsch_comp1!=NULL) {
+        ind=0;
+        for (k=0; k<frame_parms->symbols_per_tti; k++) {
+            for (i=0; i<12*frame_parms->N_RB_DL/2; i++) {
+                I[ind] = pdsch_comp1[(2*frame_parms->N_RB_DL*12*k)+4*i];
+                Q[ind] = pdsch_comp1[(2*frame_parms->N_RB_DL*12*k)+4*i+1];
+                ind++;
+            }
+        }
+        fl_set_xyplot_data(form->pdsch_comp1,I,Q,ind,"","","");
+    }
+
+    if (pdsch_mag1 != NULL) {
+        ind=0;
+        for (k=0; k<frame_parms->symbols_per_tti; k++) {
+            for (i=0; i<12*frame_parms->N_RB_DL/2; i++) {
+	      I[ind] = pdsch_mag1[(2*frame_parms->N_RB_DL*12*k)+4*i]*cos(i*2*M_PI/(12*frame_parms->N_RB_DL/2));
+	      Q[ind] = pdsch_mag1[(2*frame_parms->N_RB_DL*12*k)+4*i+1]*sin(i*2*M_PI/(12*frame_parms->N_RB_DL/2));
+	      ind++;
+            }
+        }
+        fl_add_xyplot_overlay(form->pdsch_comp1,1,I,Q,ind,FL_GREEN);
+    }
+
+    if (pdsch_magb1 != NULL) {
+        ind=0;
+        for (k=0; k<frame_parms->symbols_per_tti; k++) {
+            for (i=0; i<12*frame_parms->N_RB_DL/2; i++) {
+	      I[ind] = pdsch_magb1[(2*frame_parms->N_RB_DL*12*k)+4*i]*cos(i*2*M_PI/(12*frame_parms->N_RB_DL/2));
+	      Q[ind] = pdsch_magb1[(2*frame_parms->N_RB_DL*12*k)+4*i+1]*sin(i*2*M_PI/(12*frame_parms->N_RB_DL/2));
+	      ind++;
+            }
+        }
+        fl_add_xyplot_overlay(form->pdsch_comp1,2,I,Q,ind,FL_RED);
+    }
+
+    if ((pdsch_mag1 != NULL) && (pdsch_magb1 != NULL)) {
+        ind=0;
+        for (k=0; k<frame_parms->symbols_per_tti; k++) {
+            for (i=0; i<12*frame_parms->N_RB_DL/2; i++) {
+	      I[ind] = 
+		(pdsch_mag1[(2*frame_parms->N_RB_DL*12*k)+4*i]+
+		 pdsch_magb1[(2*frame_parms->N_RB_DL*12*k)+4*i])*
+		cos(i*2*M_PI/(12*frame_parms->N_RB_DL/2));
+	      Q[ind] = 
+		(pdsch_mag1[(2*frame_parms->N_RB_DL*12*k)+4*i+1]+
+		 pdsch_magb1[(2*frame_parms->N_RB_DL*12*k)+4*i+1])*
+		sin(i*2*M_PI/(12*frame_parms->N_RB_DL/2));
+	      ind++;
+            }
+        }
+        fl_add_xyplot_overlay(form->pdsch_comp1,3,I,Q,ind,FL_BLUE);
+    }
+ 
+
+    /*    
     // PDSCH Throughput
     memcpy((void*)tput_time_ue[UE_id],(void*)&tput_time_ue[UE_id][1],(TPUT_WINDOW_LENGTH-1)*sizeof(float));
     memcpy((void*)tput_ue[UE_id],(void*)&tput_ue[UE_id][1],(TPUT_WINDOW_LENGTH-1)*sizeof(float));
@@ -669,6 +828,9 @@ void phy_scope_UE(FD_lte_phy_scope_ue *form,
     fl_set_xyplot_data(form->pdsch_tput,tput_time_ue[UE_id],tput_ue[UE_id],TPUT_WINDOW_LENGTH,"","","");
     
     fl_set_xyplot_ybounds(form->pdsch_tput,0,tput_ue_max[UE_id]);
+    */
+
+    fl_unfreeze_form(form);
 
     fl_check_forms();
 
diff --git a/openair1/PHY/TOOLS/lte_phy_scope.h b/openair1/PHY/TOOLS/lte_phy_scope.h
index e5fe841e5a6..11e1d9b1801 100644
--- a/openair1/PHY/TOOLS/lte_phy_scope.h
+++ b/openair1/PHY/TOOLS/lte_phy_scope.h
@@ -62,6 +62,8 @@ typedef struct {
     FL_OBJECT * pdcch_llr;
     FL_OBJECT * pdsch_comp;
     FL_OBJECT * pdsch_llr;
+    FL_OBJECT * pdsch_comp1;
+    FL_OBJECT * pdsch_llr1;
     FL_OBJECT * pdsch_tput;
     FL_OBJECT * button_0;
 } FD_lte_phy_scope_ue;
diff --git a/openair1/PHY/impl_defs_lte.h b/openair1/PHY/impl_defs_lte.h
index 8b657fac2f1..2121c962593 100644
--- a/openair1/PHY/impl_defs_lte.h
+++ b/openair1/PHY/impl_defs_lte.h
@@ -795,19 +795,22 @@ typedef struct {
   /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
   /// - second index: ? [0..168*N_RB_DL[
   int32_t **rxdataF_comp0;
-  /// \brief Received frequency-domain signal after extraction and channel compensation.
-  /// - first index: ? [0..7] (hard coded) accessed via \c round
-  /// - second index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
-  /// - third index: ? [0..168*N_RB_DL[
-  int32_t **rxdataF_comp1[8];
+  /// \brief Received frequency-domain signal after extraction and channel compensation for the second stream. For the SIC receiver we need to store the history of this for each harq process and round
+  /// - 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[ 
+  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
   /// - second index: ? [0..168*N_RB_DL[
   int32_t **dl_ch_estimates_ext;
-  /// \brief Downlink cross-correlation of MIMO channel estimates (unquantized PMI) extracted in PRBS.
-  /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
-  /// - second index: ? [0..168*N_RB_DL[
-  int32_t **dl_ch_rho_ext;
+  /// \brief Downlink cross-correlation of MIMO channel estimates (unquantized PMI) extracted in PRBS. For the SIC receiver we need to store the history of this for each harq process and round
+  /// - 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[
+  int32_t **dl_ch_rho_ext[8][8];
   /// \brief Downlink cross-correlation of MIMO channel estimates (unquantized PMI) extracted in PRBS.
   /// - first index: ? [0..7] (hard coded) FIXME! accessed via \c nb_antennas_rx
   /// - second index: ? [0..168*N_RB_DL[
diff --git a/openair1/SIMULATION/LTE_PHY/dlsim.c b/openair1/SIMULATION/LTE_PHY/dlsim.c
index 63fd6a23f11..fa7a7f20706 100644
--- a/openair1/SIMULATION/LTE_PHY/dlsim.c
+++ b/openair1/SIMULATION/LTE_PHY/dlsim.c
@@ -53,7 +53,6 @@
 #include "SCHED/defs.h"
 #include "SCHED/vars.h"
 #include "LAYER2/MAC/vars.h"
-
 #include "OCG_vars.h"
 #include "UTIL/LOG/log.h"
 #include "UTIL/LISTS/list.h"
@@ -65,7 +64,7 @@ extern unsigned char offset_mumimo_llr_drange_fix;
 #include "PHY/TOOLS/lte_phy_scope.h"
 #endif
 
-
+#define PRINT_BYTES
 
 //#define AWGN
 //#define NO_DCI
@@ -248,17 +247,19 @@ int main(int argc, char **argv) {
   double forgetting_factor=0.0; //in [0,1] 0 means a new channel every time, 1 means keep the same channel
   double iqim=0.0;
 
-  uint8_t extended_prefix_flag=0,transmission_mode=1,n_tx=1,n_rx=2;
+  uint8_t extended_prefix_flag=0,transmission_mode=1,n_tx=1,n_rx=1;
   uint16_t Nid_cell=0;
 
-  int eNB_id = 0, eNB_id_i = 1;
-  unsigned char mcs1=0,mcs2=0,mcs_i=0,dual_stream_UE = 0,awgn_flag=0,round,dci_flag=0;
+  int8_t eNB_id = 0, eNB_id_i = 1;
+  unsigned char mcs1=0,mcs2=0,mcs_i=0,awgn_flag=0,round,dci_flag=0;
   unsigned char i_mod = 2;
   unsigned short NB_RB;
   unsigned char Ns,l,m;
   uint16_t tdd_config=3;
   uint16_t n_rnti=0x1234;
   int n_users = 1;
+  RX_type_t rx_type=rx_standard;
+
 
   SCM_t channel_model=Rayleigh1;
   //  unsigned char *input_data,*decoded_output;
@@ -268,15 +269,15 @@ int main(int argc, char **argv) {
   unsigned int ret;
   unsigned int coded_bits_per_codeword=0,nsymb,dci_cnt,tbs=0;
  
-  unsigned int tx_lev=0,tx_lev_dB=0,trials,errs[4]={0,0,0,0},errs2[4]={0,0,0,0},round_trials[4]={0,0,0,0},dci_errors=0,dlsch_active=0,num_layers;
+  unsigned int tx_lev=0,tx_lev_dB=0,trials,errs[2][4],round_trials[4]={0,0,0,0},dci_errors=0,dlsch_active=0,num_layers;
   int re_allocated;
   char fname[32],vname[32];
   FILE *bler_fd;
   char bler_fname[256];
   FILE *time_meas_fd;
   char time_meas_fname[256];
-  FILE *tikz_fd;
-  char tikz_fname[256];
+  //FILE *tikz_fd;
+  //char tikz_fname[256];
 
   FILE *input_trch_fd=NULL;
   unsigned char input_trch_file=0;
@@ -302,7 +303,7 @@ int main(int argc, char **argv) {
   uint8_t rx_sample_offset = 0;
   //char stats_buffer[4096];
   //int len;
-  uint8_t num_rounds = 4,fix_rounds=0;
+  uint8_t num_rounds = 4;
   uint8_t subframe=7;
   int u;
   int n=0;
@@ -317,18 +318,19 @@ int main(int argc, char **argv) {
   // void *data;
   // int ii;
   int bler;
-  double blerr[4],uncoded_ber,avg_ber;
+  double blerr[2][4],uncoded_ber,avg_ber;
   short *uncoded_ber_bit=NULL;
   uint8_t N_RB_DL=25,osf=1;
   uint8_t fdd_flag = 0;
 #ifdef XFORMS
   FD_lte_phy_scope_ue *form_ue;
   char title[255];
+  int xforms = 0;
 #endif
   uint32_t DLSCH_RB_ALLOC = 0x1fff;
   int numCCE=0;
   int dci_length_bytes=0,dci_length=0;
-  double BW = 5.0;
+  double BW = 7.68;
   int common_flag=0,TPC=0;
 
   double cpu_freq_GHz;
@@ -341,7 +343,7 @@ int main(int argc, char **argv) {
   int llr8_flag=0;
 
   double effective_rate=0.0;
-  char channel_model_input[10]="I";
+  char channel_model_input[17]="I";
 
   int TB0_active = 1;
   uint32_t perfect_ce = 0;
@@ -350,6 +352,7 @@ int main(int argc, char **argv) {
   LTE_DL_eNB_HARQ_t *dlsch0_eNB_harq;
   uint8_t Kmimo;
 
+  mod_sym_t **sic_buffer;
 
   opp_enabled=1; // to enable the time meas
 
@@ -361,6 +364,7 @@ int main(int argc, char **argv) {
   //signal(SIGABRT, handler); 
 
   logInit();
+  set_glog(LOG_INFO, LOG_MED);
 
   // default parameters
   n_frames = 1000;
@@ -368,7 +372,7 @@ int main(int argc, char **argv) {
   num_layers = 1;
   perfect_ce = 0;
 
-  while ((c = getopt (argc, argv, "ahdpZDe:m:n:o:s:f:t:c:g:r:F:x:y:z:AM:N:I:i:O:R:S:C:T:b:u:v:w:B:PLl:Y")) != -1) {
+  while ((c = getopt (argc, argv, "aAb:B:c:C:dDe:f:F:g:hi:I:l:Lm:M:n:N:o:O:pPr:R:s:S:t:T:u:v:w:x:Xy:Yz:Z")) != -1) {
     switch (c)
       {
       case 'a':
@@ -435,7 +439,7 @@ int main(int argc, char **argv) {
 	num_pdcch_symbols=atoi(optarg);
 	break;
       case 'g':
-	memcpy(channel_model_input,optarg,10);
+	memcpy(channel_model_input,optarg,17);
 	switch((char)*optarg) {
 	case 'A': 
 	  channel_model=SCM_A;
@@ -479,6 +483,24 @@ int main(int argc, char **argv) {
 	case 'N':
 	  channel_model=AWGN;
 	  break;
+	case 'P':
+	  channel_model=Rayleigh1_orthogonal;
+	  break;
+	case 'Q':
+	  channel_model=Rayleigh1_orth_eff_ch_TM4_prec_real; // for DUALSTREAM_UNIFORM_PRECODING1 when interf is precancelled
+	break;
+	case 'R':
+	  channel_model=Rayleigh1_orth_eff_ch_TM4_prec_imag; // for DUALSTREAM_UNIFORM_PRECODINGj when interf is precancelled
+	  break;
+	case 'S':
+	  channel_model=Rayleigh8_orth_eff_ch_TM4_prec_real;//when interf is precancelled
+	  break;
+	case 'T':
+	  channel_model=Rayleigh8_orth_eff_ch_TM4_prec_imag;//when interf is precancelled
+	  break;
+	case 'U':
+	  channel_model = TS_SHIFT;
+	  break;
 	default:
 	  msg("Unsupported channel model!\n");
 	  exit(-1);
@@ -489,6 +511,7 @@ int main(int argc, char **argv) {
 	if ((transmission_mode!=1) &&
 	    (transmission_mode!=2) &&
 	    (transmission_mode!=3) &&
+	    (transmission_mode!=4) &&
 	    (transmission_mode!=5) &&
 	    (transmission_mode!=6)) {
 	  msg("Unsupported transmission mode %d\n",transmission_mode);
@@ -536,10 +559,9 @@ int main(int argc, char **argv) {
 	n_rnti=atoi(optarg);
 	break;	
       case 'u':
-	dual_stream_UE=1;
-	openair_daq_vars.use_ia_receiver = 1;
-	if ((n_tx!=2) || (transmission_mode!=5)) {
-	  msg("IA receiver only supported for TM5!");
+	rx_type = (RX_type_t) atoi(optarg);
+	if (rx_type<rx_standard || rx_type>rx_IC_dual_stream) {
+	  printf("Unsupported rx type %d\n",rx_type);
 	  exit(-1);
 	}
 	break;
@@ -563,6 +585,9 @@ int main(int argc, char **argv) {
 	test_perf=atoi(optarg);
 	//print_perf =1;
 	break;
+      case 'X':
+	xforms = 1;
+	break;
       case 'Z':
 	dump_table=1;
 	break;
@@ -571,7 +596,7 @@ int main(int argc, char **argv) {
 	break;
       case 'h':
       default:
-	printf("%s -h(elp) -a(wgn on) -d(ci decoding on) -p(extended prefix on) -m mcs1 -M mcs2 -n n_frames -s snr0 -x transmission mode (1,2,5,6) -y TXant -z RXant -I trch_file\n",argv[0]);
+	printf("%s -h(elp) -a(wgn on) -d(ci decoding on) -p(extended prefix on) -m mcs1 -M mcs2 -n n_frames -s snr0 -x transmission mode (1,2,3,5,6) -y TXant -z RXant -I trch_file\n",argv[0]);
 	printf("-h This message\n");
 	printf("-a Use AWGN channel and not multipath\n");
 	printf("-c Number of PDCCH symbols\n");
@@ -584,18 +609,20 @@ int main(int argc, char **argv) {
 	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("-g [A:M] Use 3GPP 25.814 SCM-A/B/C/D('A','B','C','D') or 36-101 EPA('E'), EVA ('F'),ETU('G') models (ignores delay spread and Ricean factor), Rayghleigh8 ('H'), Rayleigh1('I'), Rayleigh1_corr('J'), Rayleigh1_anticorr ('K'), Rice8('L'), Rice1('M')\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("-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_real22 ('Q'), Rayleigh1_orth_eff_ch_TM4_prec_imag ('R'),   \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");
 	printf("-y Number of TX antennas used in eNB\n");
 	printf("-z Number of RX antennas used in UE\n");
 	printf("-t MCS of interfering UE\n");
 	printf("-R Number of HARQ rounds (fixed)\n");
-	printf("-M Turns on calibration mode for abstraction.\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("-I Input filename for TrCH data (binary)\n");
-	printf("-u Enables the Interference Aware Receiver for TM5 (default is normal receiver)\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);
 	break;
       }
@@ -605,20 +632,20 @@ int main(int argc, char **argv) {
     switch (N_RB_DL) {
     case 6:
       if (rballocset==0) DLSCH_RB_ALLOC = 0x3f;
-      BW = 1.25;
+      BW = 30.72/16;
       num_pdcch_symbols = 3;
       break;
     case 25:
       if (rballocset==0) DLSCH_RB_ALLOC = 0x1fff;
-      BW = 5.00;
+      BW = 30.72/4;
       break;
     case 50:
       if (rballocset==0) DLSCH_RB_ALLOC = 0x1ffff;
-      BW = 10.00;
+      BW = 30.72/2;
       break;
     case 100:
       if (rballocset==0) DLSCH_RB_ALLOC = 0x1ffffff;
-      BW = 20.00;
+      BW = 30.72;
       break;
     }
     NB_RB=conv_nprb(0,DLSCH_RB_ALLOC,N_RB_DL);
@@ -628,37 +655,55 @@ int main(int argc, char **argv) {
 
   NB_RB=conv_nprb(0,DLSCH_RB_ALLOC,N_RB_DL);
 
-  if ((transmission_mode > 1) && (n_tx != 2))
+  if ((transmission_mode > 1) && (n_tx != 2)) {
     printf("n_tx must be >1 for transmission_mode %d\n",transmission_mode);
+    exit(-1);
+  }
+
+  if (((transmission_mode==1) || (transmission_mode==2)) && (rx_type != rx_standard)) {
+    printf("only standard rx available for TM1 and TM2\n");
+    exit(-1);
+  }
+  if (((transmission_mode==5) || (transmission_mode==6)) && (rx_type == rx_IC_dual_stream)) {
+    printf("only standard rx or single stream IC available for TM5 and TM6\n");
+    exit(-1);
+  }
+
 
 #ifdef XFORMS
+  if (xforms==1) {
   fl_initialize (&argc, argv, NULL, 0, 0);
   form_ue = create_lte_phy_scope_ue();
   sprintf (title, "LTE PHY SCOPE eNB");
   fl_show_form (form_ue->lte_phy_scope_ue, FL_PLACE_HOTSPOT, FL_FULLBORDER, title);  
 
-  if (!dual_stream_UE==0) {
+  /*
+  if (rx_type==rx_IC_single_stream) {
     openair_daq_vars.use_ia_receiver = 1;
     fl_set_button(form_ue->button_0,1);
     fl_set_object_label(form_ue->button_0, "IA Receiver ON");
     fl_set_object_color(form_ue->button_0, FL_GREEN, FL_GREEN);
   }
+  */
+  }
 #endif
 
-  if (transmission_mode==5) {
+  if (transmission_mode==5) { 
     n_users = 2;
-    printf("dual_stream_UE=%d\n", dual_stream_UE);
+    eNB_id_i = PHY_vars_UE->n_connected_eNB;
   }
+  else 
+    eNB_id_i = eNB_id;
+
 
   lte_param_init(n_tx,n_rx,transmission_mode,extended_prefix_flag,fdd_flag,Nid_cell,tdd_config,N_RB_DL,osf,perfect_ce);  
 
-  eNB_id_i = PHY_vars_UE->n_connected_eNB;
-  
   printf("Setting mcs1 = %d\n",mcs1);
   printf("Setting mcs2 = %d\n",mcs2);
   printf("NPRB = %d\n",NB_RB);
   printf("n_frames = %d\n",n_frames);
   printf("Transmission mode %d with %dx%d antenna configuration, Extended Prefix %d\n",transmission_mode,n_tx,n_rx,extended_prefix_flag);
+  printf("Using receiver type %d\n", rx_type);
 
   snr1 = snr0+snr_int;
   printf("SNR0 %f, SNR1 %f\n",snr0,snr1);
@@ -675,26 +720,35 @@ int main(int argc, char **argv) {
 
   frame_parms = &PHY_vars_eNB->lte_frame_parms;
 
-  s_re = malloc(2*sizeof(double*));
+  s_re = malloc(2*sizeof(double*)); //transmitted signal (Sent)
   s_im = malloc(2*sizeof(double*));
-  r_re = malloc(2*sizeof(double*));
+  r_re = malloc(2*sizeof(double*)); //received signal
   r_im = malloc(2*sizeof(double*));
   //  r_re0 = malloc(2*sizeof(double*));
   //  r_im0 = malloc(2*sizeof(double*));
 
   nsymb = (PHY_vars_eNB->lte_frame_parms.Ncp == 0) ? 14 : 12;
 
+
+
   printf("Channel Model= (%s,%d)\n",channel_model_input, channel_model);
-  printf("SCM-A=%d, SCM-B=%d, SCM-C=%d, SCM-D=%d, EPA=%d, EVA=%d, ETU=%d, Rayleigh8=%d, Rayleigh1=%d, Rayleigh1_corr=%d, Rayleigh1_anticorr=%d, Rice1=%d, Rice8=%d\n",
-	 SCM_A, SCM_B, SCM_C, SCM_D, EPA, EVA, ETU, Rayleigh8, Rayleigh1, Rayleigh1_corr, Rayleigh1_anticorr, Rice1, Rice8);
-  
+  printf("SCM-A=%d, SCM-B=%d, SCM-C=%d, SCM-D=%d, EPA=%d, EVA=%d, ETU=%d, Rayleigh8=%d, Rayleigh1=%d, Rayleigh1_corr=%d, Rayleigh1_anticorr=%d, Rice1=%d, Rice8=%d, Rayleigh1_orthogonal=%d, Rayleigh1_orth_eff_ch_TM4_prec_real22=%d, Rayleigh1_orth_eff_ch_TM4_prec_imag=%d, Rayleigh8_orth_eff_ch_TM4_prec_real=%d,  Rayleigh8_orth_eff_ch_TM4_prec_imag=%d , TS_SHIFT=%d\n",
+	 SCM_A, SCM_B, SCM_C, SCM_D, EPA, EVA, ETU, Rayleigh8, Rayleigh1, Rayleigh1_corr, Rayleigh1_anticorr, Rice1, Rice8, Rayleigh1_orthogonal, Rayleigh1_orth_eff_ch_TM4_prec_real, Rayleigh1_orth_eff_ch_TM4_prec_imag, Rayleigh8_orth_eff_ch_TM4_prec_real, Rayleigh8_orth_eff_ch_TM4_prec_imag, TS_SHIFT);
   if(transmission_mode==5)
-    sprintf(bler_fname,"bler_tx%d_chan%d_nrx%d_mcs%d_mcsi%d_u%d_imod%d.csv",transmission_mode,channel_model,n_rx,mcs1,mcs_i,dual_stream_UE,i_mod);
+    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_rec%d_chan%d_nrx%d_mcs%d_mcsi%d_abstr_perf_ce.csv",transmission_mode,rx_type,channel_model,n_rx,mcs1, mcs2);
+  	else
+    	sprintf(bler_fname,"bler_tx%d_rec%d_chan%d_nrx%d_mcs%d_mcsi%d_abstr.csv",transmission_mode,rx_type,channel_model,n_rx,mcs1, mcs2);
   else
-    sprintf(bler_fname,"bler_tx%d_chan%d_nrx%d_mcs%d.csv",transmission_mode,channel_model,n_rx,mcs1);
+    if (perfect_ce==1)
+		sprintf(bler_fname,"bler_tx%d_rec%d_chan%d_nrx%d_mcs%d_mcsi%d_perf_ce.csv",transmission_mode,rx_type,channel_model,n_rx,mcs1, mcs2);
+		else
+    		sprintf(bler_fname,"bler_tx%d_rec%d_chan%d_nrx%d_mcs%d_mcsi%d.csv",transmission_mode,rx_type,channel_model,n_rx,mcs1, mcs2);
   
   bler_fd = fopen(bler_fname,"w");
-  fprintf(bler_fd,"SNR; MCS; TBS; rate; err0; trials0; err1; trials1; err2; trials2; err3; trials3; dci_err\n");
+  fprintf(bler_fd,"SNR; MCS1; MCS2; TBS1; TBS2; rate; err0_st1; err0_st2 trials0; err1_st1; err1_st2; trials1; err2_st1; err2_st2; trials2; err3_st1; err3_st2; trials3; dci_err\n");
   
   if (test_perf != 0) {
     char hostname[1024];
@@ -710,8 +764,18 @@ int main(int argc, char **argv) {
   }
   
   if(abstx){
-    // CSV file 
-    sprintf(csv_fname,"dataout_tx%d_u2%d_mcs%d_chan%d_nsimus%d_R%d.m",transmission_mode,dual_stream_UE,mcs1,channel_model,n_frames,num_rounds);
+    // CSV file  // add here second stream mcs
+    
+    if (transmission_mode == 5)
+      sprintf(csv_fname,"dataout_tx%d_u2%d_mcs%d_chan%d_nsimus%d_R%d_abstr.m",transmission_mode,rx_type,mcs1,channel_model,n_frames,num_rounds);
+    
+    else 
+      if (perfect_ce==1)
+		sprintf(csv_fname,"dataout_tx%d_mcs%d_mcsi%d_chan%d_nsimus%d_R%d_abstr_perf_ce.m",transmission_mode,mcs1,mcs2,channel_model,n_frames,num_rounds);
+ 	else
+		 sprintf(csv_fname,"dataout_tx%d_mcs%d_mcsi%d_chan%d_nsimus%d_R%d_abstr.m",transmission_mode,mcs1,mcs2,channel_model,n_frames,num_rounds);
+
+     // sprintf(csv_fname,"dataout_tx%d_mcs%d_mcs_interf%d_chan%d_nsimus%d_R%d_abstr_old.m",transmission_mode,mcs1,mcs2,channel_model,n_frames,num_rounds);
     csv_fd = fopen(csv_fname,"w");
     fprintf(csv_fd,"data_all%d=[",mcs1);
   }
@@ -719,7 +783,8 @@ 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 = fopen(tikz_fname,"w");
+  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)
     {
@@ -835,7 +900,7 @@ int main(int argc, char **argv) {
   UL_alloc_pdu.ndi     = 1;
   UL_alloc_pdu.TPC     = 0;
   UL_alloc_pdu.cqi_req = 1;
-
+  
   CCCH_alloc_pdu.type               = 0;
   CCCH_alloc_pdu.vrb_type           = 0;
   CCCH_alloc_pdu.rballoc            = CCCH_RB_ALLOC;
@@ -891,14 +956,14 @@ int main(int argc, char **argv) {
     exit(-1);
   }
 
-  if ((transmission_mode == 3) || (transmission_mode==4)) 
+  if ((transmission_mode == 3) || (transmission_mode==4) || (transmission_mode==8))  
     Kmimo=2;
   else
     Kmimo=1;
 
   for (k=0;k<n_users;k++) {
     // Create transport channel structures for 2 transport blocks (MIMO)
-    for (i=0;i<2;i++) {
+    for (i=0;i<2;i++) { //i is a number of spatial streams
       PHY_vars_eNB->dlsch_eNB[k][i] = new_eNB_dlsch(Kmimo,8,N_RB_DL,0);
       if (!PHY_vars_eNB->dlsch_eNB[k][i]) {
 	printf("Can't get eNB dlsch structures\n");
@@ -932,6 +997,11 @@ int main(int argc, char **argv) {
   }
 
 
+  sic_buffer = (mod_sym_t **) malloc16(frame_parms->nb_antennas_tx*sizeof(mod_sym_t*) );
+  for (i=0; i<frame_parms->nb_antennas_tx; i++) {
+    sic_buffer[i] = malloc16_clear(FRAME_LENGTH_COMPLEX_SAMPLES_NO_PREFIX*sizeof(mod_sym_t));
+  }
+
   if (input_fd==NULL) {
 
 
@@ -1005,7 +1075,7 @@ int main(int argc, char **argv) {
 	      break;
 	    }
 	  }
-	  else {
+	  else { //fdd
 	    switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
 	    case 6:
 	      dci_length = sizeof_DCI1_1_5MHz_FDD_t;
@@ -1076,7 +1146,7 @@ int main(int argc, char **argv) {
 	  num_dci++;
 	  num_ue_spec_dci++;
 	}
-	else {
+	else { //common flag =1
 	  if (PHY_vars_eNB->lte_frame_parms.frame_type == TDD) {
 	    
 	    switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
@@ -1134,7 +1204,7 @@ int main(int argc, char **argv) {
 	      break;
 	    }
 	  }
-	  else {
+	  else { // fdd
 	    switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
 	    case 6:
 	      dci_length = sizeof_DCI1A_1_5MHz_FDD_t;
@@ -1212,10 +1282,10 @@ int main(int argc, char **argv) {
 	  
 	}
 	break;
-      case 3:
+      case 3: //LARGE CDD
 	if (common_flag == 0) {
 	  
-	  if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx == 2) {
+	  if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx == 2) {// here DCI does not contain any precoder information. matrix is fixed as identity, but dont forget aboy cycling
 
 	    if (PHY_vars_eNB->lte_frame_parms.frame_type == TDD) {
 	      
@@ -1281,8 +1351,8 @@ int main(int argc, char **argv) {
 		break;
 	      }
 	    }
-	  
-	    else {
+	 
+	    else { // fdd
 	      switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
 	      case 6:
 		dci_length = sizeof_DCI2A_1_5MHz_2A_FDD_t;
@@ -1342,7 +1412,7 @@ int main(int argc, char **argv) {
 	      }	  
 	    }
 	  }
-	  else if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx == 4) {
+	  else if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx == 4) { //4 antenna, needs diff precoding codebook index depeneding on layers
 
 	  }
       
@@ -1369,8 +1439,8 @@ int main(int argc, char **argv) {
 	  num_dci++;
 	  num_ue_spec_dci++;
 	}
-	else {
-	  if (PHY_vars_eNB->lte_frame_parms.frame_type == TDD) {
+	else { //commonn flag 1
+	  if (PHY_vars_eNB->lte_frame_parms.frame_type == TDD) { //tdd
 	    
 	    switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
 	    case 6:
@@ -1427,7 +1497,7 @@ int main(int argc, char **argv) {
 	      break;
 	    }
 	  }
-	  else {
+	  else { //fdd
 	    switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
 	    case 6:
 	      dci_length = sizeof_DCI1A_1_5MHz_FDD_t;
@@ -1507,7 +1577,7 @@ int main(int argc, char **argv) {
 	printf("Generated DCI format 2A (Transmission Mode 3)\n");
 	break;
 
-      case 4:
+      case 4: // !!! this dci format contains precoder information
 	if (common_flag == 0) {
 	  
 	  if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx == 2) {
@@ -1516,7 +1586,7 @@ int main(int argc, char **argv) {
 	      
 	      switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
 	      case 6:
-		dci_length = sizeof_DCI2_1_5MHz_2A_TDD_t;
+		dci_length = sizeof_DCI2_1_5MHz_2A_TDD_t; 
 		dci_length_bytes = sizeof(DCI2_1_5MHz_2A_TDD_t);
 		((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = DLSCH_RB_ALLOC;
 		((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
@@ -1528,14 +1598,16 @@ int main(int argc, char **argv) {
 		((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
 		((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
 		((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
+		((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tb_swap			  = 0;
+		((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi   			  = 0;
 		break;
 	      case 25:
 		dci_length = sizeof_DCI2_5MHz_2A_TDD_t;
 		dci_length_bytes = sizeof(DCI2_5MHz_2A_TDD_t);
 		((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rah              = 0;
 		((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rballoc          = DLSCH_RB_ALLOC;
-		((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->TPC              = 0;
-		((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->dai              = 0;
+		((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->TPC 	        = 0; 
+		((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->dai  	        = 0; 
 		((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->harq_pid         = 0;
 		((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs1             = mcs1;  
 		((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi1             = 1;
@@ -1543,6 +1615,9 @@ int main(int argc, char **argv) {
 		((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
 		((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
 		((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
+		((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tb_swap          = 0;
+		((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi          	= 0;
+
 		break;
 	      case 50:
 		dci_length = sizeof_DCI2_10MHz_2A_TDD_t;
@@ -1558,6 +1633,9 @@ int main(int argc, char **argv) {
 		((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
 		((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
 		((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
+		((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tb_swap          = 0;
+		((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi          	 = 0;
+
 		break;
 	      case 100:
 		((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rah              = 0;
@@ -1571,6 +1649,8 @@ int main(int argc, char **argv) {
 		((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
 		((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
 		((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
+		((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tb_swap          = 0;
+		((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi          	 = 0;
 		dci_length = sizeof_DCI2_20MHz_2A_TDD_t;
 		dci_length_bytes = sizeof(DCI2_20MHz_2A_TDD_t);
 		break;
@@ -1591,6 +1671,8 @@ int main(int argc, char **argv) {
 		((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
 		((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
 		((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
+		((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->tb_swap          = 0;
+		((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi          	  = 0;
 		break;
 	      case 25:
 		dci_length = sizeof_DCI2_5MHz_2A_FDD_t;
@@ -1605,6 +1687,8 @@ int main(int argc, char **argv) {
 		((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
 		((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
 		((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
+		((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->tb_swap          = 0;
+		((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi          	= 0;
 		break;
 	      case 50:
 		dci_length = sizeof_DCI2_10MHz_2A_FDD_t;
@@ -1619,6 +1703,8 @@ int main(int argc, char **argv) {
 		((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
 		((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
 		((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
+		((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->tb_swap          = 0;
+		((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi          	 = 0;
 		break;
 	      case 100:
 		dci_length = sizeof_DCI2_20MHz_2A_FDD_t;
@@ -1633,6 +1719,8 @@ int main(int argc, char **argv) {
 		((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->mcs2             = mcs2;  
 		((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->ndi2             = 1;
 		((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->rv2              = 0;
+		((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[k])->tb_swap          = 0;
+		((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[k])->tpmi          	= 0;
 		break;
 	      }	  
 	    }
@@ -1664,7 +1752,7 @@ int main(int argc, char **argv) {
 	  num_dci++;
 	  num_ue_spec_dci++;
 	}
-	else {
+	else { //common_flag==1
 	  if (PHY_vars_eNB->lte_frame_parms.frame_type == TDD) {
 	    
 	    switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
@@ -1895,18 +1983,6 @@ int main(int argc, char **argv) {
     }
   }
 
-  // this is for user 0 only
-  coded_bits_per_codeword = get_G(&PHY_vars_eNB->lte_frame_parms,
-				  PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->nb_rb,
-				  PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->rb_alloc,
-				  get_Qm(PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->mcs),
-				  PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->Nl,
-				  num_pdcch_symbols,
-				  0,subframe);
-  
-  uncoded_ber_bit = (short*) malloc(sizeof(short)*coded_bits_per_codeword);
-  printf("uncoded_ber_bit=%p\n",uncoded_ber_bit);
-
   snr_step = input_snr_step;
   PHY_vars_UE->high_speed_flag = 1;
   PHY_vars_UE->ch_est_alpha=0;
@@ -1918,19 +1994,11 @@ int main(int argc, char **argv) {
 
     for (SNR=snr0;SNR<snr1;SNR+=snr_step) {
       PHY_vars_UE->frame_rx=0;
-      errs[0]=0;
-      errs[1]=0;
-      errs[2]=0;
-      errs[3]=0;
-      errs2[0]=0;
-      errs2[1]=0;
-      errs2[2]=0;
-      errs2[3]=0;
-      round_trials[0] = 0;
-      round_trials[1] = 0;
-      round_trials[2] = 0;
-      round_trials[3] = 0;
-
+      for (i=0; i<4; i++) {
+	errs[0][i]=0;
+	errs[1][i]=0;
+	round_trials[i] = 0;
+      }
       dci_errors=0;
       avg_ber = 0;
 
@@ -2086,6 +2154,39 @@ int main(int argc, char **argv) {
 		      break;
 		    }
 		    break;
+		  case 4:
+		    switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) { 
+		     case 6:
+		      ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
+		      ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 0;
+		      ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
+		      ((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = 0;
+		      memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu_1[0],sizeof(DCI2_1_5MHz_2A_TDD_t));
+		      break;
+		    case 25:
+		      ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
+		      ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 0;
+		      ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
+		      ((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = 0;
+		      memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu_1[0],sizeof(DCI2_5MHz_2A_TDD_t));
+		      break;
+		    case 50:
+		      ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
+		      ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 0;
+		      ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
+		      ((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = 0;
+		      memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu_1[0],sizeof(DCI2_10MHz_2A_TDD_t));
+		      break;
+		    case 100:
+		      ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
+		      ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 0;
+		      ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
+		      ((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = 0;
+		      memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu_1[0],sizeof(DCI2_20MHz_2A_TDD_t));
+		      break;
+		    }
+		    break; 
+	
 		  case 5:
 		    DLSCH_alloc_pdu2_1E[0].ndi             = trials&1;
 		    DLSCH_alloc_pdu2_1E[0].rv              = 0;
@@ -2152,6 +2253,38 @@ int main(int argc, char **argv) {
 		      break;
 		    }
 		    break;
+		  case 4:
+		    switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) { 
+		     case 6:
+		      ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
+		      ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 0;
+		      ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
+		      ((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = 0;
+		      memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu_1[0],sizeof(DCI2_1_5MHz_2A_FDD_t));
+		      break;
+		    case 25:
+		      ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
+		      ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 0;
+		      ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
+		      ((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = 0;
+		      memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu_1[0],sizeof(DCI2_5MHz_2A_FDD_t));
+		      break;
+		    case 50:
+		      ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
+		      ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 0;
+		      ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
+		      ((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = 0;
+		      memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu_1[0],sizeof(DCI2_10MHz_2A_FDD_t));
+		      break;
+		    case 100:
+		      ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
+		      ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 0;
+		      ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
+		      ((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = 0;
+		      memcpy(&dci_alloc[0].dci_pdu[0],&DLSCH_alloc_pdu_1[0],sizeof(DCI2_20MHz_2A_FDD_t));
+		      break;
+		    }
+		    break; 
 		  case 5:
 		    DLSCH_alloc_pdu2_1E[0].ndi             = trials&1;
 		    DLSCH_alloc_pdu2_1E[0].rv              = 0;
@@ -2257,6 +2390,71 @@ int main(int argc, char **argv) {
 		      break;
 		    }
 		    break;
+		  case 4:
+		    switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
+		    case 6:
+		      if (TB0_active==1) {
+			((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
+			((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = round&3;
+			((DCI2_1_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
+			((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[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;
+			((DCI2_1_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_1_5MHz_2A_TDD_t));
+		      break;
+		    case 25:
+		      if (TB0_active==1) {
+			((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
+			((DCI2_5MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = round&3;
+			((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;
+		      }
+		      else {  // deactivate TB0
+			((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));
+		      break;
+		    case 50:
+		      if (TB0_active==1) {
+			((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
+			((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = round&3;
+			((DCI2_10MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
+			((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])->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;
+			((DCI2_10MHz_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_10MHz_2A_TDD_t));
+		      break;
+		    case 100:
+		      if (TB0_active==1) {
+			((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
+			((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = round&3;
+			((DCI2_20MHz_2A_TDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
+			((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])->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;
+			((DCI2_20MHz_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_20MHz_2A_TDD_t));
+		      break;
+		    }
+		    break;
+		   
 		  case 5:
 		    DLSCH_alloc_pdu2_1E[0].ndi             = trials&1;
 		    DLSCH_alloc_pdu2_1E[0].rv              = round&3;
@@ -2355,6 +2553,72 @@ int main(int argc, char **argv) {
 		      break;
 		    }
 		    break;
+		  case 4:
+		    switch (PHY_vars_eNB->lte_frame_parms.N_RB_DL) {
+		    case 6:
+		      if (TB0_active==1) {
+			((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
+			((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = round&3;
+			((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
+			((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv2              = round&3;
+		      }
+		      else {  // deactivate TB0
+			((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->mcs1             = 0;
+			((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = 1;
+			((DCI2_1_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
+			((DCI2_1_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_1_5MHz_2A_FDD_t));
+		      break;
+		    case 25:
+		      if (TB0_active==1) {
+			((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
+			((DCI2_5MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = round&3;
+			((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;
+		      }
+		      else {  // deactivate TB0
+			((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));
+		      break;
+		    case 50:
+		      if (TB0_active==1) {
+			((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
+			((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = round&3;
+			((DCI2_10MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
+			((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])->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;
+			((DCI2_10MHz_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_10MHz_2A_FDD_t));
+		      break;
+		    case 100:
+		      if (TB0_active==1) {
+			((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi1             = trials&1;
+			((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->rv1              = round&3;
+			((DCI2_20MHz_2A_FDD_t *)&DLSCH_alloc_pdu_1[0])->ndi2             = trials&1;
+			((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])->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;
+			((DCI2_20MHz_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_20MHz_2A_FDD_t));
+		      break;
+		    }
+		    break;  
+		    
+		    
 		  case 5:
 		    DLSCH_alloc_pdu2_1E[0].ndi             = trials&1;
 		    DLSCH_alloc_pdu2_1E[0].rv              = round&3;
@@ -2398,12 +2662,12 @@ int main(int argc, char **argv) {
 	      
 	      if ((SNR==snr0) && (trials==0) && (round==0))
 		printf("User %d, cw %d: Rate = %f (%f bits/dim) (G %d, TBS %d, mod %d, pdcch_sym %d, ndi %d)\n",
-		       k,cw,rate,rate*get_Qm(PHY_vars_eNB->dlsch_eNB[k][0]->harq_processes[0]->mcs),
+		       k,cw,rate,rate*get_Qm(PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->mcs),
 		       coded_bits_per_codeword,
 		       tbs,
-		       get_Qm(PHY_vars_eNB->dlsch_eNB[k][0]->harq_processes[0]->mcs),
+		       get_Qm(PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->mcs), //changed dlsch_eNB[k][0]
 		       num_pdcch_symbols,
-		       PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->round);
+		       PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->round);//changed dlsch_eNB[k][0]
 
 	      // use the PMI from previous trial
 	      if (DLSCH_alloc_pdu2_1E[0].tpmi == 5) {
@@ -2454,10 +2718,11 @@ int main(int argc, char **argv) {
 			       0,
 			       PHY_vars_eNB->dlsch_eNB[k][cw],
 			       coded_bits_per_codeword,
-			       0,
+			       cw,
 			       subframe<<1);
 	      stop_meas(&PHY_vars_eNB->dlsch_scrambling_stats);	      
 
+#ifdef PRINT_BYTES
 	      if (n_frames==1) {
 		for (s=0;s<PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->C;s++) {
 		  if (s<PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->Cminus)
@@ -2468,9 +2733,10 @@ int main(int argc, char **argv) {
 		  Kr_bytes = Kr>>3;
 	      
 		  for (i=0;i<Kr_bytes;i++)
-		    printf("%d : (%x)\n",i,PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->c[s][i]);
+		    printf("cw%d   %d : (%x)\n",cw,i,PHY_vars_eNB->dlsch_eNB[k][cw]->harq_processes[0]->c[s][i]);
 		}
 	      }
+#endif
 	      }
 	  
 	      start_meas(&PHY_vars_eNB->dlsch_modulation_stats);	      
@@ -2568,6 +2834,28 @@ int main(int argc, char **argv) {
 		s_im[aa][i] = ((double)(((short *)PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][aa]))[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti) +(i<<1)+1]);
 	      }
 	      else {
+                if (transmission_mode==4) {
+                 r_re[0][i] = ((double)(((short *)PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][0]))[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti) +(i<<1)])+((double)(((short *)PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][1]))[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti) +(i<<1)]);
+                    r_im[0][i] = ((double)(((short *)PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][0]))[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti) +(i<<1)+1])+((double)(((short *)PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][1]))[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti) +(i<<1)+1]);
+
+                    r_re[1][i] = ((double)(((short *)PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][0]))[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti) +(i<<1)])-((double)(((short *)PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][1]))[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti) +(i<<1)]);
+                    r_im[1][i] = ((double)(((short *)PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][0]))[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti) +(i<<1)+1])-((double)(((short *)PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][1]))[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti) +(i<<1)+1]);
+             //   printf("r_re0 = %d\n",r_re[0][i]);
+		//printf("r_im0 = %d\n",r_im[0][i]);
+		//printf("r_re1 = %d\n",r_re[1][i]);
+		//printf("r_im1 = %d\n",r_im[1][i]);
+	//	r_re[0][i] = ((double)(((short *)PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][0]))[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti) +(i<<1)]);
+          //          r_im[0][i] = ((double)(((short *)PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][0]))[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti) +(i<<1)+1]);
+
+            //        r_re[1][i] = ((double)(((short *)PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][1]))[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti) +(i<<1)]);
+              //      r_im[1][i] = ((double)(((short *)PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][1]))[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti) +(i<<1)+1]);
+//	   printf("r_re0 = %d\n",r_re[0][i]);
+//		printf("r_im0 = %d\n",r_im[0][i]);
+//		printf("r_re1 = %d\n",r_re[1][i]);
+//		printf("r_im1 = %d\n",r_im[1][i]);
+		    		    
+		}
+     else {
 		for (aarx=0;aarx<PHY_vars_UE->lte_frame_parms.nb_antennas_rx;aarx++) {
 		  if (aa==0) {
 		    r_re[aarx][i] = ((double)(((short *)PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][aa]))[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti) +(i<<1)]);
@@ -2577,7 +2865,7 @@ int main(int argc, char **argv) {
 		    r_re[aarx][i] += ((double)(((short *)PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][aa]))[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti) +(i<<1)]);
 		    r_im[aarx][i] += ((double)(((short *)PHY_vars_eNB->lte_eNB_common_vars.txdata[eNB_id][aa]))[(2*subframe*PHY_vars_UE->lte_frame_parms.samples_per_tti) +(i<<1)+1]);
 		  }
- 
+		}
 		}
 	      }
 	    }
@@ -2597,6 +2885,7 @@ int main(int argc, char **argv) {
 	  }
 	
 	
+	  //  freq_channel(eNB2UE[0], NB_RB,12*NB_RB + 1);
 	if(abstx){
 	  if (trials==0 && round==0) {
 	    // calculate freq domain representation to compute SINR
@@ -2830,18 +3119,18 @@ int main(int argc, char **argv) {
 						   dci_alloc_rx,1,
 						   eNB_id,
 						   subframe);
-		  //printf("dci_cnt %d\n",dci_cnt);
+		  printf("dci_cnt %d\n",dci_cnt);
 		
 		  if (dci_cnt==0) {
 		    dlsch_active = 0;
 		    if (round==0) {
 		      dci_errors++;
 		      round=5;
-		      errs[0]++;
+		      errs[0][0]++;
 		      //round_trials[0]++;
 
 		      if (n_frames==1)
-			printf("DCI error trial %d errs[0] %d\n",trials,errs[0]);
+			printf("DCI error trial %d errs[0][0] %d\n",trials,errs[0][0]);
 		    }
 		    //		for (i=1;i<=round;i++)
 		    //		  round_trials[i]--;
@@ -2850,7 +3139,10 @@ int main(int argc, char **argv) {
 		
 		  for (i=0;i<dci_cnt;i++) {
 		    //		    printf("Generating dlsch parameters for RNTI %x\n",dci_alloc_rx[i].rnti);
-		    if (round == 0) PHY_vars_UE->dlsch_ue[0][0]->harq_processes[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid]->first_tx=1;
+		    if (round == 0) {
+		      PHY_vars_UE->dlsch_ue[0][0]->harq_processes[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid]->first_tx=1;
+		      PHY_vars_UE->dlsch_ue[0][1]->harq_processes[PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid]->first_tx=1;
+		    }
 		    if ((dci_alloc_rx[i].rnti == n_rnti) && 
 			(generate_ue_dlsch_params_from_dci(0,
 							   dci_alloc_rx[i].dci_pdu,
@@ -2862,13 +3154,13 @@ int main(int argc, char **argv) {
 							   SI_RNTI,
 							   0,
 							   P_RNTI)==0)) {
-		      //dump_dci(&PHY_vars_UE->lte_frame_parms,&dci_alloc_rx[i]);
+		      dump_dci(&PHY_vars_UE->lte_frame_parms,&dci_alloc_rx[i]);
 		      coded_bits_per_codeword = get_G(&PHY_vars_eNB->lte_frame_parms,
 						      PHY_vars_UE->dlsch_ue[0][0]->harq_processes[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid]->nb_rb,
 						      PHY_vars_UE->dlsch_ue[0][0]->harq_processes[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid]->rb_alloc,
 						      get_Qm(PHY_vars_UE->dlsch_ue[0][0]->harq_processes[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid]->mcs),
 						      PHY_vars_UE->dlsch_ue[0][0]->harq_processes[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid]->Nl,
-PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
+						      PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 						      0,subframe);
 		      /*
 			rate = (double)dlsch_tbs25[get_I_TBS(PHY_vars_UE->dlsch_ue[0][0]->harq_processes[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid]->mcs)][PHY_vars_UE->dlsch_ue[0][0]->nb_rb-1]/(coded_bits_per_codeword);
@@ -2882,7 +3174,7 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 		      dlsch_active = 0;
 		      if (round==0) {
 			dci_errors++;
-			errs[0]++;
+			errs[0][0]++;
 			//round_trials[0]++;
 			round=5;
 
@@ -2900,7 +3192,10 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 
 		  PHY_vars_UE->lte_ue_pdcch_vars[0]->crnti = n_rnti;
 		  PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols = num_pdcch_symbols;
-		  if (round == 0) PHY_vars_UE->dlsch_ue[0][0]->harq_processes[0]->first_tx=1;
+		  if (round == 0) {
+		    PHY_vars_UE->dlsch_ue[0][0]->harq_processes[0]->first_tx=1;
+		    PHY_vars_UE->dlsch_ue[0][1]->harq_processes[0]->first_tx=1;
+		  }
 		  switch (transmission_mode) {
 		  case 1:
 		  case 2:
@@ -2933,13 +3228,14 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 		    generate_ue_dlsch_params_from_dci(0,
 						      &DLSCH_alloc_pdu_1[0],
 						      (common_flag==0)? C_RNTI : SI_RNTI,
-						      (common_flag==0)? format2 : format1A,
+						      (common_flag==0)? format2 : format1A,//format1A only for a codeblock
 						      PHY_vars_UE->dlsch_ue[0],
 						      &PHY_vars_UE->lte_frame_parms,
 						      PHY_vars_UE->pdsch_config_dedicated,
 						      SI_RNTI,
 						      0,
 						      P_RNTI);
+
 		    break;
 		  case 5:
 		  case 6:
@@ -2963,12 +3259,14 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 	      if (dlsch_active == 1) {
 		if ((Ns==(1+(2*subframe))) && (l==0)) {// process PDSCH symbols 1,2,3,4,5,(6 Normal Prefix)
 
-		  if ((transmission_mode == 5) && 
-		      (PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid]->dl_power_off==0) &&
-		      (openair_daq_vars.use_ia_receiver ==1)) {
-		    dual_stream_UE = 1;
-		  } else {
-		    dual_stream_UE = 0;
+
+		  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) &&
+			(openair_daq_vars.use_ia_receiver ==1)) {
+		      rx_type = rx_IC_single_stream;
+		    } else {
+		      rx_type = rx_standard;
+		    }
 		  }
 
 
@@ -2985,7 +3283,7 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 				   subframe,
 				   m,
 				   (m==PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols)?1:0,
-				   dual_stream_UE,
+				   rx_type,
 				   i_mod,
 				   PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid)==-1)
 			{
@@ -3010,7 +3308,7 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 				     subframe,
 				     m,
 				     0,
-				     dual_stream_UE,
+				     rx_type,
 				     i_mod,
 				     PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid)==-1)
 			  {
@@ -3035,7 +3333,7 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 				     subframe,
 				     m,
 				     0,
-				     dual_stream_UE,
+				     rx_type,
 				     i_mod,
 				     PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid)==-1)
 			  {
@@ -3047,10 +3345,33 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 		  }
 		if (test_perf ==0 ) {
 		  if ((n_frames==1) && (Ns==(2+(2*subframe))) && (l==0))  {
-		    write_output("ch0.m","ch0",eNB2UE[0]->ch[0],eNB2UE[0]->channel_length,1,8);
+		    
+		    
+		    write_output("chanF11.m","chF11",eNB2UE[0]->chF[0],12*NB_RB,1,8);
+		    write_output("chan11.m","ch11",eNB2UE[0]->ch[0],eNB2UE[0]->channel_length,1,8);
+		    if ( PHY_vars_eNB->lte_frame_parms.nb_antennas_rx==2 && PHY_vars_eNB->lte_frame_parms.nb_antennas_tx==1 ){
+		      write_output("chan21.m","ch21",eNB2UE[0]->ch[1],eNB2UE[0]->channel_length,1,8);
+		    }
+		    if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx>1){
+		    write_output("chan12.m","ch12",eNB2UE[0]->ch[1],eNB2UE[0]->channel_length,1,8);
+		      if ( PHY_vars_eNB->lte_frame_parms.nb_antennas_rx>1){
+		    write_output("chan21.m","ch21",eNB2UE[0]->ch[2],eNB2UE[0]->channel_length,1,8);
+		    write_output("chan22.m","ch22",eNB2UE[0]->ch[3],eNB2UE[0]->channel_length,1,8);
+		      }
+		     
+		    }
+		    
+		    
+		  /*for (aarx=0;aarx<PHY_vars_UE->lte_frame_parms.nb_antennas_rx; aarx++) {
+		      for (aa=0;aa<PHY_vars_UE->lte_frame_parms.nb_antennas_tx; aa++) {
+		      sprintf(fname,"ch%d%d.m",(aarx+1), (aa+1));
+		      write_output(fname,"ch",eNB2UE[0]->ch[2*aarx+aa],eNB2UE[0]->channel_length,1,8);
+		      }
+		    } */
+		    /*write_output("ch0.m","ch0",eNB2UE[0]->ch[0],eNB2UE[0]->channel_length,1,8);
 		    if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx>1)
-		      write_output("ch1.m","ch1",eNB2UE[0]->ch[PHY_vars_eNB->lte_frame_parms.nb_antennas_rx],eNB2UE[0]->channel_length,1,8);
-
+		      write_output("ch1.m","ch1",eNB2UE[0]->ch[PHY_vars_eNB->lte_frame_parms.nb_antennas_rx],eNB2UE[0]->channel_length,1,8);*/
+		    
 		    //common vars
 		    write_output("rxsig0.m","rxs0", &PHY_vars_UE->lte_ue_common_vars.rxdata[0][0],10*PHY_vars_UE->lte_frame_parms.samples_per_tti,1,1);
 		    write_output("rxsigF0.m","rxsF0", &PHY_vars_UE->lte_ue_common_vars.rxdataF[0][0],PHY_vars_UE->lte_frame_parms.ofdm_symbol_size*nsymb,1,1);
@@ -3076,9 +3397,10 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 				   PHY_vars_UE->lte_frame_parms.ofdm_symbol_size*nsymb/2,1,1);
 		    
 		    //pdsch_vars
-		    dump_dlsch2(PHY_vars_UE,eNB_id,coded_bits_per_codeword,round);
+		    dump_dlsch2(PHY_vars_UE,eNB_id,coded_bits_per_codeword,round,PHY_vars_UE->dlsch_ue[0][1]->current_harq_pid );
 		    //dump_dlsch2(PHY_vars_UE,eNB_id_i,coded_bits_per_codeword);
-		    write_output("dlsch_e.m","e",PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->e,coded_bits_per_codeword,1,4);
+		  //  write_output("dlsch_e.m","e",PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->e,coded_bits_per_codeword,1,4);
+		    
 
 		    //pdcch_vars
 		    write_output("pdcchF0_ext.m","pdcchF_ext", PHY_vars_UE->lte_ue_pdcch_vars[eNB_id]->rxdataF_ext[0],2*3*PHY_vars_UE->lte_frame_parms.ofdm_symbol_size,1,1);
@@ -3105,211 +3427,303 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 	    }
 	  }
 
-	  for (int cw=Kmimo-1;cw>=0;cw--){
-	  PHY_vars_UE->dlsch_ue[0][cw]->rnti = (common_flag==0) ? n_rnti: SI_RNTI;
-	  coded_bits_per_codeword = get_G(&PHY_vars_eNB->lte_frame_parms,
-					  PHY_vars_eNB->dlsch_eNB[0][cw]->harq_processes[0]->nb_rb,
-					  PHY_vars_eNB->dlsch_eNB[0][cw]->harq_processes[0]->rb_alloc,
-					  get_Qm(PHY_vars_eNB->dlsch_eNB[0][cw]->harq_processes[0]->mcs),
-					  PHY_vars_eNB->dlsch_eNB[0][cw]->harq_processes[0]->Nl,
-					  num_pdcch_symbols,
-					  0,subframe);
-
-	  PHY_vars_UE->dlsch_ue[0][cw]->harq_processes[PHY_vars_UE->dlsch_ue[0][cw]->current_harq_pid]->G = coded_bits_per_codeword;
-	  
+	  for (int cw=0; cw<Kmimo;cw++){
+	    PHY_vars_UE->dlsch_ue[0][cw]->rnti = (common_flag==0) ? n_rnti: SI_RNTI;
+	    coded_bits_per_codeword = get_G(&PHY_vars_eNB->lte_frame_parms,
+					    PHY_vars_eNB->dlsch_eNB[0][cw]->harq_processes[0]->nb_rb,
+					    PHY_vars_eNB->dlsch_eNB[0][cw]->harq_processes[0]->rb_alloc,
+					    get_Qm(PHY_vars_eNB->dlsch_eNB[0][cw]->harq_processes[0]->mcs),
+					    PHY_vars_eNB->dlsch_eNB[0][cw]->harq_processes[0]->Nl,
+					    num_pdcch_symbols,
+					    0,subframe);
+	    PHY_vars_UE->dlsch_ue[0][cw]->harq_processes[PHY_vars_UE->dlsch_ue[0][cw]->current_harq_pid]->G = coded_bits_per_codeword;
 
-	  /*
-	  // calculate uncoded BLER
-	  uncoded_ber=0;
-	  for (i=0;i<coded_bits_per_codeword;i++) 
-	    if (PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->e[i] != (PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[0][i]<0)) {
-	      uncoded_ber_bit[i] = 1;
-	      uncoded_ber++;
-	    }
-	    else
-	      uncoded_ber_bit[i] = 0;
+	    if (n_frames==1) {
+	      printf("Kmimo=%d, cw=%d, G=%d, TBS=%d\n",Kmimo,cw,coded_bits_per_codeword,
+		     PHY_vars_UE->dlsch_ue[0][cw]->harq_processes[PHY_vars_UE->dlsch_ue[0][cw]->current_harq_pid]->TBS);
+	    
+	      // calculate uncoded BER
+	      uncoded_ber_bit = (short*) malloc(sizeof(short)*coded_bits_per_codeword);
+	      AssertFatal(uncoded_ber_bit, "uncoded_ber_bit==NULL");
+	      sprintf(fname,"dlsch%d_rxF_r%d_cw%d_llr.m",eNB_id,round, cw);
+	      sprintf(vname,"dl%d_r%d_cw%d_llr",eNB_id,round, cw);
+	      write_output(fname,vname, PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[cw],coded_bits_per_codeword,1,0);
+	      sprintf(fname,"dlsch_cw%d_e.m", cw);
+	      sprintf(vname,"dlsch_cw%d_e", cw);
+	       write_output(fname, vname,PHY_vars_eNB->dlsch_eNB[0][cw]->harq_processes[0]->e,coded_bits_per_codeword,1,4);
+	      uncoded_ber=0;
+	      for (i=0;i<coded_bits_per_codeword;i++) 
+		if (PHY_vars_eNB->dlsch_eNB[0][cw]->harq_processes[0]->e[i] != (PHY_vars_UE->lte_ue_pdsch_vars[0]->llr[cw][i]<0)) {
+		  uncoded_ber_bit[i] = 1;
+		  uncoded_ber++;
+		}
+		else
+		  uncoded_ber_bit[i] = 0;
+	      
+	      uncoded_ber/=coded_bits_per_codeword;
+	      avg_ber += uncoded_ber;
+	      sprintf(fname,"cw%d_uncoded_ber_bit.m", cw);
+	      sprintf(vname,"uncoded_ber_bit_cw%d", cw);
+	      write_output(fname, vname,uncoded_ber_bit,coded_bits_per_codeword,1,0);
+	      printf("cw %d, uncoded ber %f\n",cw,uncoded_ber);
+	      
 
-	  uncoded_ber/=coded_bits_per_codeword;
-	  avg_ber += uncoded_ber;
-	  
-	  if (n_frames==1)
-	    write_output("uncoded_ber_bit.m","uncoded_ber_bit",uncoded_ber_bit,coded_bits_per_codeword,1,0);
-	  */
+	      free(uncoded_ber_bit);
+	      uncoded_ber_bit = NULL;  
 
-	  start_meas(&PHY_vars_UE->dlsch_unscrambling_stats);	      
-	  dlsch_unscrambling(&PHY_vars_UE->lte_frame_parms,
-			     0,
-			     PHY_vars_UE->dlsch_ue[0][cw],
-			     coded_bits_per_codeword,
-			     PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[cw],
-			     0,
-			     subframe<<1);
-	  stop_meas(&PHY_vars_UE->dlsch_unscrambling_stats);	      
-
-	  start_meas(&PHY_vars_UE->dlsch_decoding_stats);
-	  ret = dlsch_decoding(PHY_vars_UE,
-			       PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[cw],		 
-			       &PHY_vars_UE->lte_frame_parms,
-			       PHY_vars_UE->dlsch_ue[0][cw],
-			       PHY_vars_UE->dlsch_ue[0][cw]->harq_processes[PHY_vars_UE->dlsch_ue[0][cw]->current_harq_pid],
-			       subframe,
-			       PHY_vars_UE->dlsch_ue[0][cw]->current_harq_pid,
-			       1,llr8_flag);
-	  stop_meas(&PHY_vars_UE->dlsch_decoding_stats); 
-
-	  if (cw==1) {
-	    if (ret <= PHY_vars_UE->dlsch_ue[0][cw]->max_turbo_iterations) {
-	    }
-	    else {
-	      errs2[round]++;
 	    }
-	  }
-	  }
-
 
-	  stop_meas(&PHY_vars_UE->phy_proc_rx);
+	    start_meas(&PHY_vars_UE->dlsch_unscrambling_stats);	      
+	    dlsch_unscrambling(&PHY_vars_UE->lte_frame_parms,
+			       0,
+			       PHY_vars_UE->dlsch_ue[0][cw],
+			       coded_bits_per_codeword,
+			       PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[cw],
+			       cw,
+			       subframe<<1);
+	    stop_meas(&PHY_vars_UE->dlsch_unscrambling_stats);	      
+
+	    start_meas(&PHY_vars_UE->dlsch_decoding_stats);
+	    ret = dlsch_decoding(PHY_vars_UE,
+				 PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->llr[cw],		 
+				 &PHY_vars_UE->lte_frame_parms,
+				 PHY_vars_UE->dlsch_ue[0][cw],
+				 PHY_vars_UE->dlsch_ue[0][cw]->harq_processes[PHY_vars_UE->dlsch_ue[0][cw]->current_harq_pid],
+				 subframe,
+				 PHY_vars_UE->dlsch_ue[0][cw]->current_harq_pid,
+				 1,llr8_flag);
+	    stop_meas(&PHY_vars_UE->dlsch_decoding_stats); 
+	    
+	    
+	    if (ret <= PHY_vars_UE->dlsch_ue[0][cw]->max_turbo_iterations ) { 
 
+	      if (cw==0) {		
+		avg_iter += ret;
+		iter_trials++;
+	      }
+	      
+	      if (n_frames==1) {
+		printf("cw %d, round %d: No DLSCH errors found, uncoded ber %f\n",cw,round,uncoded_ber);
+		#ifdef PRINT_BYTES
+		for (s=0;s<PHY_vars_UE->dlsch_ue[0][cw]->harq_processes[0]->C;s++) {
+		  if (s<PHY_vars_UE->dlsch_ue[0][cw]->harq_processes[0]->Cminus)
+		    Kr = PHY_vars_UE->dlsch_ue[0][cw]->harq_processes[0]->Kminus;
+		  else
+		    Kr = PHY_vars_UE->dlsch_ue[0][cw]->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][cw]->harq_processes[0]->c[s][i],
+			   PHY_vars_UE->dlsch_ue[0][cw]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][cw]->harq_processes[0]->c[s][i]);
+		}
+#endif
+	      }
+	      
+	      PHY_vars_UE->total_TBS[eNB_id] =  PHY_vars_UE->total_TBS[eNB_id] + PHY_vars_UE->dlsch_ue[eNB_id][cw]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][cw]->current_harq_pid]->TBS;
 
-	  if (ret <= PHY_vars_UE->dlsch_ue[0][0]->max_turbo_iterations) {
-		
-	    avg_iter += ret;
-	    iter_trials++;
-	    if (n_frames==1) 
-	      printf("No DLSCH errors found (round %d),uncoded ber %f\n",round,uncoded_ber);
-
-	    PHY_vars_UE->total_TBS[eNB_id] =  PHY_vars_UE->total_TBS[eNB_id] + PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->TBS;
-	    TB0_active = 0;
-	    if (PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode == LARGE_CDD) {   //try to decode second stream using SIC
+	      if (PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->mimo_mode == LARGE_CDD) {   //try to decode second stream using SIC
 	      /*
-		for (round = 0 ; round < PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->round ; round++) {
-		// re-encoding of first stream
-		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_eNB_harq->mimo_mode    = LARGE_CDD;
-		dlsch0_eNB_harq->rb_alloc[0]  = dlsch0_ue_harq->rb_alloc[0];
-		dlsch0_eNB_harq->nb_rb        = dlsch0_ue_harq->nb_rb;
-		dlsch0_eNB_harq->mcs          = dlsch0_ue_harq->mcs;
-		dlsch0_eNB_harq->rvidx        = dlsch0_ue_harq->rvidx;
-		dlsch0_eNB_harq->Nl           = dlsch0_ue_harq->Nl;
-		
-		dlsch0_eNB_harq->TBS          = dlsch0_ue_harq->TBS;
-		dlsch0_eNB_harq->dl_power_off = dlsch0_ue_harq->dl_power_off;
-		dlsch0_eNB_harq->status       = dlsch0_ue_harq->status;
-
-		PHY_vars_UE->dlsch_eNB[eNB_id]->active       = PHY_vars_UE->dlsch_ue[eNB_id][0]->active;
-		PHY_vars_UE->dlsch_eNB[eNB_id]->rnti         = PHY_vars_UE->dlsch_ue[eNB_id][0]->rnti;
-
-		dlsch_encoding(PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->b,
-			       &PHY_vars_UE->lte_frame_parms,
-			       num_pdcch_symbols,
-			       PHY_vars_UE->dlsch_eNB[0],
-			       0,subframe,
-			       &PHY_vars_UE->dlsch_rate_matching_stats,
-			       &PHY_vars_UE->dlsch_turbo_encoding_stats,
-			       &PHY_vars_UE->dlsch_interleaving_stats
-			       );	
-
-			       //scrambling
-
-		//modulation
-
-		//stripping (from matched filter output?)
-
-		//detection of second stream	
-	      }
+	      //for (round = 0 ; round < PHY_vars_UE->dlsch_ue[eNB_id][0]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][0]->current_harq_pid]->round ; round++) {
+	      // we assume here that the second stream has a lower MCS and is thus more likely to be decoded
+	      // re-encoding of second stream
+	      dlsch0_ue_harq = PHY_vars_UE->dlsch_ue[eNB_id][1]->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_eNB_harq->mimo_mode    = LARGE_CDD;
+	      dlsch0_eNB_harq->rb_alloc[0]  = dlsch0_ue_harq->rb_alloc[0];
+	      dlsch0_eNB_harq->nb_rb        = dlsch0_ue_harq->nb_rb;
+	      dlsch0_eNB_harq->mcs          = dlsch0_ue_harq->mcs;
+	      dlsch0_eNB_harq->rvidx        = dlsch0_ue_harq->rvidx;
+	      dlsch0_eNB_harq->Nl           = dlsch0_ue_harq->Nl;
+	      dlsch0_eNB_harq->round        = dlsch0_ue_harq->round;
+	      
+	      dlsch0_eNB_harq->TBS          = dlsch0_ue_harq->TBS;
+	      dlsch0_eNB_harq->dl_power_off = dlsch0_ue_harq->dl_power_off;
+	      dlsch0_eNB_harq->status       = dlsch0_ue_harq->status;
+	      
+	      PHY_vars_UE->dlsch_eNB[eNB_id]->active       = PHY_vars_UE->dlsch_ue[eNB_id][1]->active;
+	      PHY_vars_UE->dlsch_eNB[eNB_id]->rnti         = PHY_vars_UE->dlsch_ue[eNB_id][1]->rnti;
+	      PHY_vars_UE->dlsch_eNB[eNB_id]->current_harq_pid         = PHY_vars_UE->dlsch_ue[eNB_id][1]->current_harq_pid;
+	      
+	      dlsch_encoding(PHY_vars_UE->dlsch_ue[eNB_id][1]->harq_processes[PHY_vars_UE->dlsch_ue[eNB_id][1]->current_harq_pid]->b,
+			     &PHY_vars_UE->lte_frame_parms,
+			     num_pdcch_symbols,
+			     PHY_vars_UE->dlsch_eNB[eNB_id],
+			     0,subframe,
+			     &PHY_vars_UE->dlsch_rate_matching_stats,
+			     &PHY_vars_UE->dlsch_turbo_encoding_stats,
+			     &PHY_vars_UE->dlsch_interleaving_stats
+			     );
+	      
+	      coded_bits_per_codeword = 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),
+					      PHY_vars_UE->dlsch_eNB[eNB_id]->harq_processes[PHY_vars_UE->dlsch_eNB[eNB_id]->current_harq_pid]->Nl,
+					      num_pdcch_symbols,
+					      0,subframe);
+	      
+	      
+	      //scrambling
+	      dlsch_scrambling(&PHY_vars_UE->lte_frame_parms,
+			       0,
+			       PHY_vars_UE->dlsch_eNB[eNB_id],
+			       coded_bits_per_codeword,
+			       0,
+			       subframe<<1);
+	      
+	      
+	      //modulation
+	      re_allocated = dlsch_modulation(sic_buffer,
+					      AMP,
+					      subframe,
+					      &PHY_vars_UE->lte_frame_parms,
+					      num_pdcch_symbols,
+					      &PHY_vars_UE->dlsch_eNB[0][0],
+					      NULL);
+	      // sic_buffer is a vector of size nb_antennas_tx, but both contain the same signal, since we do modulation without precoding
+	      // precoding is contained in effective channel estimate
+	      // compute the norm of the effective channel for both receive antennas -> alphha[0], alphha[2]
+	      // multiply with the norm of the effective channnel
 	      */
-	    }
-	  }	
-	  else {
-	    errs[round]++;
+	      
+	      //stripping (from matched filter output of first stream = rxdataF_comp0)
+	      // this is pseudocode
+	      /*
+		for (i=0; i<frame_parms->nb_antennas_rx; i++) {
+		PHY_vars_UE->lte_ue_pdsch_vars[eNB_id].rxdataF_ext[i] -=   alpha[i].*sic_buffer[i];
+		}
+	      */
+	      
+	      //apply rho to output 
+	      /*
+		dlsch_channel_compensation(PHY_vars_UE->lte_ue_pdsch_vars[eNB_id].rxdataF_ext,
+					   PHY_vars_UE->lte_ue_pdsch_vars[eNB_id].dl_ch_rho_ext[harq_pid][round],
+					   PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_mag1,
+					   PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->dl_ch_magb1,
+					   PHY_vars_UE->lte_ue_pdsch_vars[eNB_id]->rxdataF_comp1,
+					   NULL,
+					   frame_parms,
+					   symbol,
+					   first_symbol_flag,
+					   i_mod,
+					   nb_rb,
+					   lte_ue_pdsch_vars[eNB_id]->log2_maxh,
+					   phy_measurements); // log2_maxh+I0_shift
+		*/
 
-	    avg_iter += ret-1;
-	    iter_trials++;
-		
-	    if (n_frames==1) {
-	      //if ((n_frames==1) || (SNR>=30)) {
-	      printf("DLSCH errors found (round %d), uncoded ber %f\n",round,uncoded_ber);
-	      for (s=0;s<PHY_vars_UE->dlsch_ue[0][0]->harq_processes[0]->C;s++) {
-		if (s<PHY_vars_UE->dlsch_ue[0][0]->harq_processes[0]->Cminus)
-		  Kr = PHY_vars_UE->dlsch_ue[0][0]->harq_processes[0]->Kminus;
-		else
-		  Kr = PHY_vars_UE->dlsch_ue[0][0]->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][0]->harq_processes[0]->c[s][i],PHY_vars_UE->dlsch_ue[0][0]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->c[s][i]);
-	      }
-	      sprintf(fname,"rxsig0_r%d.m",round);
-	      sprintf(vname,"rxs0_r%d.m",round);
-	      write_output(fname,vname, &PHY_vars_UE->lte_ue_common_vars.rxdata[0][0],10*PHY_vars_UE->lte_frame_parms.samples_per_tti,1,1);
-	      sprintf(fname,"rxsigF0_r%d.m",round);
-	      sprintf(vname,"rxs0F_r%d.m",round);
-	      write_output(fname,vname, &PHY_vars_UE->lte_ue_common_vars.rxdataF[0][0],2*PHY_vars_UE->lte_frame_parms.ofdm_symbol_size*nsymb,2,1);
-	      if (PHY_vars_UE->lte_frame_parms.nb_antennas_rx>1) {
-		sprintf(fname,"rxsig1_r%d.m",round);
-		sprintf(vname,"rxs1_r%d.m",round);
-		write_output(fname,vname, PHY_vars_UE->lte_ue_common_vars.rxdata[1],PHY_vars_UE->lte_frame_parms.samples_per_tti,1,1);
-		sprintf(fname,"rxsig1F_r%d.m",round);
-		sprintf(vname,"rxs1F_r%d.m",round);
-		write_output(fname,vname, PHY_vars_UE->lte_ue_common_vars.rxdataF[1],2*PHY_vars_UE->lte_frame_parms.ofdm_symbol_size*nsymb,2,1);
+
+	      //detection of second stream	
+	      //}
+	      
 	      }
-	      sprintf(fname,"dlsch00_r%d.m",round);
-	      sprintf(vname,"dl00_r%d.m",round);
-	      write_output(fname,vname,
-			   &(PHY_vars_UE->lte_ue_common_vars.dl_ch_estimates[eNB_id][0][0]),
-			   PHY_vars_UE->lte_frame_parms.ofdm_symbol_size*nsymb,1,1);
-	      if (PHY_vars_UE->lte_frame_parms.nb_antennas_rx>1) {
-		sprintf(fname,"dlsch01_r%d.m",round);
-		sprintf(vname,"dl01_r%d.m",round);
-		write_output(fname,vname,
-			     &(PHY_vars_UE->lte_ue_common_vars.dl_ch_estimates[eNB_id][1][0]),
-			     PHY_vars_UE->lte_frame_parms.ofdm_symbol_size*nsymb/2,1,1);
+	    }	
+	    else {
+	      errs[cw][round]++;
+	      
+	      if (cw==0) {
+		avg_iter += ret-1;
+		iter_trials++;
 	      }
-	      if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx>1) {
-		sprintf(fname,"dlsch10_r%d.m",round);
-		sprintf(vname,"dl10_r%d.m",round);
-		write_output(fname,vname,
-			     &(PHY_vars_UE->lte_ue_common_vars.dl_ch_estimates[eNB_id][2][0]),
-			     PHY_vars_UE->lte_frame_parms.ofdm_symbol_size*nsymb/2,1,1);
+	      
+	        if (cw==1) {
+		avg_iter += ret-1;
+		iter_trials++;
 	      }
-	      if ((PHY_vars_UE->lte_frame_parms.nb_antennas_rx>1) && (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx>1)) {
-		sprintf(fname,"dlsch11_r%d.m",round);
-		sprintf(vname,"dl11_r%d.m",round);
-		write_output(fname,vname,
-			     &(PHY_vars_UE->lte_ue_common_vars.dl_ch_estimates[eNB_id][3][0]),
-			     PHY_vars_UE->lte_frame_parms.ofdm_symbol_size*nsymb/2,1,1);
+	      
+	      if (n_frames==1) {
+		//if ((n_frames==1) || (SNR>=30)) {
+		printf("cw %d, round %d: DLSCH errors found, uncoded ber %f\n",cw,round,uncoded_ber);
+#ifdef PRINT_BYTES
+		for (s=0;s<PHY_vars_UE->dlsch_ue[0][cw]->harq_processes[0]->C;s++) {
+		  if (s<PHY_vars_UE->dlsch_ue[0][cw]->harq_processes[0]->Cminus)
+		    Kr = PHY_vars_UE->dlsch_ue[0][cw]->harq_processes[0]->Kminus;
+		  else
+		    Kr = PHY_vars_UE->dlsch_ue[0][cw]->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][cw]->harq_processes[0]->c[s][i],
+			   PHY_vars_UE->dlsch_ue[0][cw]->harq_processes[0]->c[s][i]^PHY_vars_eNB->dlsch_eNB[0][cw]->harq_processes[0]->c[s][i]);
+		}
+#endif
 	      }
-	      //pdsch_vars
-	      dump_dlsch2(PHY_vars_UE,eNB_id,coded_bits_per_codeword,round);
-	      /*
+	    }
+	  }
+	
+	  stop_meas(&PHY_vars_UE->phy_proc_rx);
+	  
+	  if (n_frames==1) {
+	    sprintf(fname,"rxsig0_r%d.m",round);
+	    sprintf(vname,"rxs0_r%d",round);
+	    write_output(fname,vname, &PHY_vars_UE->lte_ue_common_vars.rxdata[0][0],10*PHY_vars_UE->lte_frame_parms.samples_per_tti,1,1);
+	    sprintf(fname,"rxsigF0_r%d.m",round);
+	    sprintf(vname,"rxs0F_r%d",round);
+	    write_output(fname,vname, &PHY_vars_UE->lte_ue_common_vars.rxdataF[0][0],2*PHY_vars_UE->lte_frame_parms.ofdm_symbol_size*nsymb,2,1);
+	    if (PHY_vars_UE->lte_frame_parms.nb_antennas_rx>1) {
+	      sprintf(fname,"rxsig1_r%d.m",round);
+	      sprintf(vname,"rxs1_r%d",round);
+	      write_output(fname,vname, PHY_vars_UE->lte_ue_common_vars.rxdata[1],PHY_vars_UE->lte_frame_parms.samples_per_tti,1,1);
+	      sprintf(fname,"rxsig1F_r%d.m",round);
+	      sprintf(vname,"rxs1F_r%d",round);
+	      write_output(fname,vname, PHY_vars_UE->lte_ue_common_vars.rxdataF[1],2*PHY_vars_UE->lte_frame_parms.ofdm_symbol_size*nsymb,2,1);
+	    }
+	    sprintf(fname,"dlsch00_r%d.m",round);
+	    sprintf(vname,"dl00_r%d",round);
+	    write_output(fname,vname,
+			 &(PHY_vars_UE->lte_ue_common_vars.dl_ch_estimates[eNB_id][0][0]),
+			 PHY_vars_UE->lte_frame_parms.ofdm_symbol_size*nsymb,1,1);
+	    if (PHY_vars_UE->lte_frame_parms.nb_antennas_rx>1) {
+	      sprintf(fname,"dlsch01_r%d.m",round);
+	      sprintf(vname,"dl01_r%d",round);
+	      write_output(fname,vname,
+			   &(PHY_vars_UE->lte_ue_common_vars.dl_ch_estimates[eNB_id][1][0]),
+			   PHY_vars_UE->lte_frame_parms.ofdm_symbol_size*nsymb/2,1,1);
+	    }
+	    if (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx>1) {
+	      sprintf(fname,"dlsch10_r%d.m",round);
+	      sprintf(vname,"dl10_r%d",round);
+	      write_output(fname,vname,
+			   &(PHY_vars_UE->lte_ue_common_vars.dl_ch_estimates[eNB_id][2][0]),
+			   PHY_vars_UE->lte_frame_parms.ofdm_symbol_size*nsymb/2,1,1);
+	    }
+	    if ((PHY_vars_UE->lte_frame_parms.nb_antennas_rx>1) && (PHY_vars_eNB->lte_frame_parms.nb_antennas_tx>1)) {
+	      sprintf(fname,"dlsch11_r%d.m",round);
+	      sprintf(vname,"dl11_r%d",round);
+	      write_output(fname,vname,
+			   &(PHY_vars_UE->lte_ue_common_vars.dl_ch_estimates[eNB_id][3][0]),
+			   PHY_vars_UE->lte_frame_parms.ofdm_symbol_size*nsymb/2,1,1);
+	    }
+	    //pdsch_vars
+	    dump_dlsch2(PHY_vars_UE,eNB_id,coded_bits_per_codeword,round,PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid);
+	    /*
 	      write_output("dlsch_e.m","e",PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->e,coded_bits_per_codeword,1,4);
 	      write_output("dlsch_ber_bit.m","ber_bit",uncoded_ber_bit,coded_bits_per_codeword,1,0);
 	      write_output("dlsch_eNB_w.m","w",PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->w[0],3*(tbs+64),1,4);
 	      write_output("dlsch_UE_w.m","w",PHY_vars_UE->dlsch_ue[0][0]->harq_processes[0]->w[0],3*(tbs+64),1,0);
-	      */
-	      
-	      if (round == 3) exit(-1);
-	    }
-	    //	    printf("round %d errors %d/%d\n",round,errs[round],trials);
-
-	    round++;
-	    //	    PHY_vars_UE->dlsch_ue[0][0]->harq_processes[0]->round++;
+	    */
+	    
+	    if (round == 3) exit(-1);
 	  }
+
 #ifdef XFORMS
-	  phy_scope_UE(form_ue, 
-		       PHY_vars_UE,
-		       eNB_id,
-		       0,// UE_id
-		       subframe); 
+	  if (xforms==1) {
+	    phy_scope_UE(form_ue, 
+			 PHY_vars_UE,
+			 eNB_id,
+			 0,// UE_id
+			 subframe); 
+	  }
 #endif
-
+	  
+	  round++;
 	}  //round
-	//      printf("\n");
 
-	if ((errs[0]>=n_frames/10) && (trials>(n_frames/2)))
-	  break;
+	//if ((errs[0][0]>=n_frames/10) && (trials>(n_frames/2)) )
+	// break;
       
 	//len = chbch_stats_read(stats_buffer,NULL,0,4096);
 	//printf("%s\n\n",stats_buffer);
@@ -3327,34 +3741,34 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 	 * get the max, min, and number of packets that exceed t>2000us
 	 */
 	double t_tx = (double)PHY_vars_eNB->phy_proc_tx.p_time/cpu_freq_GHz/1000.0;        
-    double t_tx_ifft = (double)PHY_vars_eNB->ofdm_mod_stats.p_time/cpu_freq_GHz/1000.0;        
-    double t_tx_mod = (double)PHY_vars_eNB->dlsch_modulation_stats.p_time/cpu_freq_GHz/1000.0;        
-    double t_tx_enc = (double)PHY_vars_eNB->dlsch_encoding_stats.p_time/cpu_freq_GHz/1000.0;        
-
-
-    double t_rx = (double)PHY_vars_UE->phy_proc_rx.p_time/cpu_freq_GHz/1000.0;        
-    double t_rx_fft = (double)PHY_vars_UE->ofdm_demod_stats.p_time/cpu_freq_GHz/1000.0;        
-    double t_rx_demod = (double)PHY_vars_UE->dlsch_rx_pdcch_stats.p_time/cpu_freq_GHz/1000.0;        
-    double t_rx_dec = (double)PHY_vars_UE->dlsch_decoding_stats.p_time/cpu_freq_GHz/1000.0;    
+	double t_tx_ifft = (double)PHY_vars_eNB->ofdm_mod_stats.p_time/cpu_freq_GHz/1000.0;        
+	double t_tx_mod = (double)PHY_vars_eNB->dlsch_modulation_stats.p_time/cpu_freq_GHz/1000.0;        
+	double t_tx_enc = (double)PHY_vars_eNB->dlsch_encoding_stats.p_time/cpu_freq_GHz/1000.0;        
+	
+	
+	double t_rx = (double)PHY_vars_UE->phy_proc_rx.p_time/cpu_freq_GHz/1000.0;        
+	double t_rx_fft = (double)PHY_vars_UE->ofdm_demod_stats.p_time/cpu_freq_GHz/1000.0;        
+	double t_rx_demod = (double)PHY_vars_UE->dlsch_rx_pdcch_stats.p_time/cpu_freq_GHz/1000.0;        
+	double t_rx_dec = (double)PHY_vars_UE->dlsch_decoding_stats.p_time/cpu_freq_GHz/1000.0;    
         
         if (t_tx > t_tx_max)
-	        t_tx_max = t_tx;
+	  t_tx_max = t_tx;
         if (t_tx < t_tx_min)
-            t_tx_min = t_tx;
+	  t_tx_min = t_tx;
         if (t_rx > t_rx_max)
-            t_rx_max = t_rx;
+	  t_rx_max = t_rx;
         if (t_rx < t_rx_min)
-            t_rx_min = t_rx;
+	  t_rx_min = t_rx;
         if (t_tx > 2000)
-            n_tx_dropped++;
+	  n_tx_dropped++;
         if (t_rx > 2000)
-            n_rx_dropped++;
+	  n_rx_dropped++;
         
         push_front(&time_vector_tx, t_tx);
         push_front(&time_vector_tx_ifft, t_tx_ifft);
         push_front(&time_vector_tx_mod, t_tx_mod);
         push_front(&time_vector_tx_enc, t_tx_enc);
-
+	
         push_front(&time_vector_rx, t_rx);
         push_front(&time_vector_rx_fft, t_rx_fft);
         push_front(&time_vector_rx_demod, t_rx_demod);
@@ -3451,20 +3865,27 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 	     (double)tx_lev_dB+10*log10(PHY_vars_UE->lte_frame_parms.ofdm_symbol_size/(NB_RB*12)),
 	     sigma2_dB);
       
-      printf("Errors (%d(%d)/%d %d/%d %d/%d %d/%d), Pe = (%e,%e,%e,%e), dci_errors %d/%d, Pe = %e => effective rate %f  (%2.1f%%,%f, %f), normalized delay %f (%f)\n",
-	     errs[0],
-	     errs2[0],
+      printf("Errors (%d(%d)/%d %d(%d)/%d %d(%d)/%d %d(%d)/%d), Pe = (%e(%e),%e(%e),%e(%e),%e(%e)), dci_errors %d/%d, Pe = %e => effective rate %f  (%2.1f%%,%f, %f), normalized delay %f (%f)\n",
+	     errs[0][0],
+	     errs[1][0],
 	     round_trials[0],
-	     errs[1],
-	     round_trials[0],
-	     errs[2],
-	     round_trials[0],
-	     errs[3],
-	     round_trials[0],
-	     (double)errs[0]/(round_trials[0]),
-	     (double)errs[1]/(round_trials[0]),
-	     (double)errs[2]/(round_trials[0]),
-	     (double)errs[3]/(round_trials[0]),
+	     errs[0][1],
+	     errs[1][1],
+	     round_trials[1],
+	     errs[0][2],
+	     errs[1][2],
+	     round_trials[2],
+	     errs[0][3],
+	     errs[1][3],
+	     round_trials[3],
+	     (double)errs[0][0]/(round_trials[0]),
+	     (double)errs[1][0]/(round_trials[0]),
+	     (double)errs[0][1]/(round_trials[1]),
+	     (double)errs[1][1]/(round_trials[1]),
+	     (double)errs[0][2]/(round_trials[2]),
+	     (double)errs[1][2]/(round_trials[2]),
+	     (double)errs[0][3]/(round_trials[3]),
+	     (double)errs[1][3]/(round_trials[3]),
 	     dci_errors,
 	     round_trials[0],
 	     (double)dci_errors/(round_trials[0]),
@@ -3472,8 +3893,8 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 	     100*effective_rate,
 	     rate,
 	     rate*get_Qm(PHY_vars_UE->dlsch_ue[0][0]->harq_processes[PHY_vars_UE->dlsch_ue[0][0]->current_harq_pid]->mcs),
-	     (1.0*(round_trials[0]-errs[0])+2.0*(round_trials[1]-errs[1])+3.0*(round_trials[2]-errs[2])+4.0*(round_trials[3]-errs[3]))/((double)round_trials[0])/(double)PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->TBS,
-	     (1.0*(round_trials[0]-errs[0])+2.0*(round_trials[1]-errs[1])+3.0*(round_trials[2]-errs[2])+4.0*(round_trials[3]-errs[3]))/((double)round_trials[0]));
+	     (1.0*(round_trials[0]-errs[0][0])+2.0*(round_trials[1]-errs[0][1])+3.0*(round_trials[2]-errs[0][2])+4.0*(round_trials[3]-errs[0][3]))/((double)round_trials[0])/(double)PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->TBS,
+	     (1.0*(round_trials[0]-errs[0][0])+2.0*(round_trials[1]-errs[0][1])+3.0*(round_trials[2]-errs[0][2])+4.0*(round_trials[3]-errs[0][3]))/((double)round_trials[0]));
       
       if (print_perf==1) {
 	printf("eNB TX function statistics (per 1ms subframe)\n\n");
@@ -3547,54 +3968,80 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 	       PHY_vars_UE->dlsch_tc_intl2_stats.trials);
       }
 
-      if ((transmission_mode != 3) && (transmission_mode != 4)) {
+            if ((transmission_mode != 3) && (transmission_mode != 4)) {
 	fprintf(bler_fd,"%f;%d;%d;%f;%d;%d;%d;%d;%d;%d;%d;%d;%d\n",
 		SNR,
 		mcs1,
 		PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->TBS,
 		rate,
-		errs[0],
+		errs[0][0],
 		round_trials[0],
-		errs[1],
+		errs[0][1],
 		round_trials[1],
-		errs[2],
+		errs[0][2],
 		round_trials[2],
-		errs[3],
+		errs[0][3],
 		round_trials[3],
 		dci_errors);
       }
       else {
-	fprintf(bler_fd,"%f;%d;%d;%d;%d;%f;%d;%d;%d;%d;%d;%d;%d;%d;%d\n",
+	fprintf(bler_fd,"%f;%d;%d;%d;%d;%f;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d\n",
 		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,
-		errs[0],
+		errs[0][0],
+		errs[1][0],
 		round_trials[0],
-		errs[1],
+		errs[0][1],
+		errs[1][1],
 		round_trials[1],
-		errs[2],
+		errs[0][2],
+		errs[1][2],
 		round_trials[2],
-		errs[3],
+		errs[0][3],
+		errs[1][3],
 		round_trials[3],
 		dci_errors);
       }
    
 
-      if(abstx){ //ABSTRACTION         
-	blerr[0] = (double)errs[0]/(round_trials[0]);
-        if(num_rounds>1){
-	  blerr[1] = (double)errs[1]/(round_trials[1]);
-	  blerr[2] = (double)errs[2]/(round_trials[2]);
-	  blerr[3] = (double)errs[3]/(round_trials[3]);
-	  fprintf(csv_fd,"%e,%e,%e,%e;\n",blerr[0],blerr[1],blerr[2],blerr[3]);
+      if(abstx){ //ABSTRACTION
+	if ((transmission_mode != 3)&& (transmission_mode != 4)) {         
+	  blerr[0][0] = (double)errs[0][0]/(round_trials[0]);
+	  
+	  if(num_rounds>1){
+	    blerr[0][1] = (double)errs[0][1]/(round_trials[1]);
+	    
+	    blerr[0][2] = (double)errs[0][2]/(round_trials[2]);
+	    
+	    blerr[0][3] = (double)errs[0][3]/(round_trials[3]);
+	    
+	    fprintf(csv_fd,"%e;%e;%e;%e;\n",blerr[0][0],blerr[0][1],blerr[0][2],blerr[0][3]);
+	  }
+	  else {
+	    fprintf(csv_fd,"%e;\n",blerr[0][0]);
+	  }
 	}
 	else {
-	  fprintf(csv_fd,"%e;\n",blerr[0]);
+	  blerr[0][0] = (double)errs[0][0]/(round_trials[0]);
+	  blerr[1][0] = (double)errs[1][0]/(round_trials[0]);
+	  if(num_rounds>1){
+	    blerr[0][1] = (double)errs[0][1]/(round_trials[1]);
+	    blerr[1][1] = (double)errs[1][1]/(round_trials[1]);
+	    blerr[0][2] = (double)errs[0][2]/(round_trials[2]);
+	    blerr[1][2] = (double)errs[1][2]/(round_trials[2]);
+	    blerr[0][3] = (double)errs[0][3]/(round_trials[3]);
+	    blerr[1][3] = (double)errs[1][3]/(round_trials[3]);
+	    fprintf(csv_fd,"%e;%e;%e;%e;%e;%e;%e;%e;\n",blerr[0][0],blerr[1][0],blerr[0][1],blerr[1][1],blerr[0][2],blerr[1][2], blerr[0][3], blerr[1][3]);
+	  }
+	  else {
+	    fprintf(csv_fd,"%e,%e;\n",blerr[0][0], blerr[1][0]);
+	  }
 	}
-      } //ABStraction
-      
+     }
+            
       if ( (test_perf != 0) && (100 * effective_rate > test_perf )) {
 	//fprintf(time_meas_fd,"SNR; MCS; TBS; rate; err0; trials0; err1; trials1; err2; trials2; err3; trials3; dci_err\n");
 	if ((transmission_mode != 3) && (transmission_mode != 4)) {
@@ -3603,13 +4050,13 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 		  mcs1,
 		  PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->TBS,
 		  rate,
-		  errs[0],
+		  errs[0][0],
 		  round_trials[0],
-		  errs[1],
+		  errs[0][1],
 		  round_trials[1],
-		  errs[2],
+		  errs[0][2],
 		  round_trials[2],
-		  errs[3],
+		  errs[0][3],
 		  round_trials[3],
 		  dci_errors);
 
@@ -3622,23 +4069,23 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 		  100*effective_rate,
 		  rate,
 		  (double)avg_iter/iter_trials,
-		  errs[0],
+		  errs[0][0],
 		  round_trials[0],
-		  errs[1],
+		  errs[0][1],
 		  round_trials[1],
-		  errs[2],
+		  errs[0][2],
 		  round_trials[2],
-		  errs[3],
+		  errs[0][3],
 		  round_trials[3],
-		  (double)errs[0]/(round_trials[0]),
-		  (double)errs[1]/(round_trials[0]),
-		  (double)errs[2]/(round_trials[0]),
-		  (double)errs[3]/(round_trials[0]),
+		  (double)errs[0][0]/(round_trials[0]),
+		  (double)errs[0][1]/(round_trials[0]),
+		  (double)errs[0][2]/(round_trials[0]),
+		  (double)errs[0][3]/(round_trials[0]),
 		  dci_errors,
 		  round_trials[0],
 		  (double)dci_errors/(round_trials[0]),
-		  (1.0*(round_trials[0]-errs[0])+2.0*(round_trials[1]-errs[1])+3.0*(round_trials[2]-errs[2])+4.0*(round_trials[3]-errs[3]))/((double)round_trials[0])/(double)PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->TBS,
-		  (1.0*(round_trials[0]-errs[0])+2.0*(round_trials[1]-errs[1])+3.0*(round_trials[2]-errs[2])+4.0*(round_trials[3]-errs[3]))/((double)round_trials[0]));
+		  (1.0*(round_trials[0]-errs[0][0])+2.0*(round_trials[1]-errs[0][1])+3.0*(round_trials[2]-errs[0][2])+4.0*(round_trials[3]-errs[0][3]))/((double)round_trials[0])/(double)PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->TBS,
+		  (1.0*(round_trials[0]-errs[0][0])+2.0*(round_trials[1]-errs[0][1])+3.0*(round_trials[2]-errs[0][2])+4.0*(round_trials[3]-errs[0][3]))/((double)round_trials[0]));
 	}
 	else {
 	  fprintf(time_meas_fd,"%f;%d;%d;%d;%d;%f;%d;%d;%d;%d;%d;%d;%d;%d;%d;",
@@ -3647,13 +4094,13 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 		  PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->TBS,
 		  PHY_vars_eNB->dlsch_eNB[0][1]->harq_processes[0]->TBS,
 		  rate,
-		  errs[0],
+		  errs[0][0],
 		  round_trials[0],
-		  errs[1],
+		  errs[0][1],
 		  round_trials[1],
-		  errs[2],
+		  errs[0][2],
 		  round_trials[2],
-		  errs[3],
+		  errs[0][3],
 		  round_trials[3],
 		  dci_errors);
 	  
@@ -3667,23 +4114,23 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 		  100*effective_rate,
 		  rate,
 		  (double)avg_iter/iter_trials,
-		  errs[0],
+		  errs[0][0],
 		  round_trials[0],
-		  errs[1],
+		  errs[0][1],
 		  round_trials[1],
-		  errs[2],
+		  errs[0][2],
 		  round_trials[2],
-		  errs[3],
+		  errs[0][3],
 		  round_trials[3],
-		  (double)errs[0]/(round_trials[0]),
-		  (double)errs[1]/(round_trials[0]),
-		  (double)errs[2]/(round_trials[0]),
-		  (double)errs[3]/(round_trials[0]),
+		  (double)errs[0][0]/(round_trials[0]),
+		  (double)errs[0][1]/(round_trials[0]),
+		  (double)errs[0][2]/(round_trials[0]),
+		  (double)errs[0][3]/(round_trials[0]),
 		  dci_errors,
 		  round_trials[0],
 		  (double)dci_errors/(round_trials[0]),
-		  (1.0*(round_trials[0]-errs[0])+2.0*(round_trials[1]-errs[1])+3.0*(round_trials[2]-errs[2])+4.0*(round_trials[3]-errs[3]))/((double)round_trials[0])/(double)PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->TBS,
-		  (1.0*(round_trials[0]-errs[0])+2.0*(round_trials[1]-errs[1])+3.0*(round_trials[2]-errs[2])+4.0*(round_trials[3]-errs[3]))/((double)round_trials[0]));
+		  (1.0*(round_trials[0]-errs[0][0])+2.0*(round_trials[1]-errs[0][1])+3.0*(round_trials[2]-errs[0][2])+4.0*(round_trials[3]-errs[0][3]))/((double)round_trials[0])/(double)PHY_vars_eNB->dlsch_eNB[0][0]->harq_processes[0]->TBS,
+		  (1.0*(round_trials[0]-errs[0][0])+2.0*(round_trials[1]-errs[0][1])+3.0*(round_trials[2]-errs[0][2])+4.0*(round_trials[3]-errs[0][3]))/((double)round_trials[0]));
 	}
 	//fprintf(time_meas_fd,"eNB_PROC_TX(%d); OFDM_MOD(%d); DL_MOD(%d); DL_SCR(%d); DL_ENC(%d); UE_PROC_RX(%d); OFDM_DEMOD_CH_EST(%d); RX_PDCCH(%d); CH_COMP_LLR(%d); DL_USCR(%d); DL_DECOD(%d);\n",
 	fprintf(time_meas_fd,"%d; %d; %d; %d; %d; %d; %d; %d; %d; %d; %d;", 
@@ -3738,7 +4185,7 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 	fprintf(time_meas_fd,"%f;%f;%f;%f\n", std_phy_proc_rx_dec, rx_dec_median, rx_dec_q1, rx_dec_q3);
 	
 
-		/*	
+	/*	
 		fprintf(time_meas_fd,"%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;",
 		PHY_vars_eNB->phy_proc_tx.trials,
 		PHY_vars_eNB->ofdm_mod_stats.trials,
@@ -3754,16 +4201,19 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
 	  */
 	  printf("[passed] effective rate : %f  (%2.1f%%,%f)): log and break \n",rate*effective_rate, 100*effective_rate, rate );
 	  break;
-	} else if (test_perf !=0 ){
-	  printf("[continue] effective rate : %f  (%2.1f%%,%f)): increase snr \n",rate*effective_rate, 100*effective_rate, rate);
-	}
+      } else if (test_perf !=0 ){
+	printf("[continue] effective rate : %f  (%2.1f%%,%f)): increase snr \n",rate*effective_rate, 100*effective_rate, rate);
+      }
 	
-	if (((double)errs[0]/(round_trials[0]))<1e-2) 
-	  break;
-      }// SNR
+      if (((double)errs[0][0]/(round_trials[0]))<1e-2 && ((double)errs[1][0]/(round_trials[0]))<1e-2) 
+	break;
       
+      if (n_frames==1)
+	break;
+
+      }// SNR
       
-    } //ch_realization
+  } //ch_realization
   
   
   fclose(bler_fd);
@@ -3781,9 +4231,6 @@ PHY_vars_UE->lte_ue_pdcch_vars[0]->num_pdcch_symbols,
     fclose(csv_fd);
   }
 
-  if (uncoded_ber_bit)
-    free(uncoded_ber_bit);
-  uncoded_ber_bit = NULL;  
   for (k=0;k<n_users;k++) {
     free(input_buffer0[k]);
     free(input_buffer1[k]);
diff --git a/openair1/SIMULATION/TOOLS/defs.h b/openair1/SIMULATION/TOOLS/defs.h
index af1b3a81a2c..d701ea29e06 100644
--- a/openair1/SIMULATION/TOOLS/defs.h
+++ b/openair1/SIMULATION/TOOLS/defs.h
@@ -174,7 +174,13 @@ typedef enum {
   Rice1,
   Rice1_corr,
   Rice1_anticorr,
-  AWGN
+  AWGN,
+  Rayleigh1_orthogonal,
+  Rayleigh1_orth_eff_ch_TM4_prec_real,
+  Rayleigh1_orth_eff_ch_TM4_prec_imag,
+  Rayleigh8_orth_eff_ch_TM4_prec_real,
+  Rayleigh8_orth_eff_ch_TM4_prec_imag,
+  TS_SHIFT,
 } SCM_t;
 
 /** 
diff --git a/openair1/SIMULATION/TOOLS/random_channel.c b/openair1/SIMULATION/TOOLS/random_channel.c
index 96665ceaef5..f44ac028298 100644
--- a/openair1/SIMULATION/TOOLS/random_channel.c
+++ b/openair1/SIMULATION/TOOLS/random_channel.c
@@ -39,6 +39,8 @@
 #include "UTIL/LOG/log.h"
 //#define DEBUG_CH
 
+extern void print_shorts(char *s,__m128i *x);
+
 void fill_channel_desc(channel_desc_t *chan_desc,
 		       uint8_t nb_tx,
 		       uint8_t nb_rx, 
@@ -119,7 +121,12 @@ void fill_channel_desc(channel_desc_t *chan_desc,
     }
   }
   else {
-    chan_desc->R_sqrt = R_sqrt;
+    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];
+	}	
   }
 
   for (i = 0; i<nb_taps; i++) {
@@ -159,6 +166,9 @@ double etu_amps_dB[] = {-1.0,-1.0,-1.0,0.0,0.0,0.0,-3.0,-5.0,-7.0};
 double default_amps_lin[] = {0.3868472 , 0.3094778 , 0.1547389 , 0.0773694 , 0.0386847 , 0.0193424 , 0.0096712 , 0.0038685};
 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},
@@ -183,6 +193,36 @@ 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[1]     = {R_sqrt_22_orthogonal_tap};
+
+// full correlation matrix for TM4 to make orthogonal effective channel
+
+
+
+
+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.70711}, {-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};
+
+
+
+//Rayleigh1_orth_eff_ch_TM4
 
 channel_desc_t *new_channel_desc_scm(uint8_t nb_tx, 
 				     uint8_t nb_rx, 
@@ -629,7 +669,7 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
       aoa = .03;
       maxDoppler = 0;
 
-      if ((nb_tx==2) && (nb_rx==1)) {
+      if ((nb_tx==2) && (nb_rx==1)) { //check this
 	R_sqrt_ptr2 = R_sqrt_21_anticorr;
       }
       else if ((nb_tx==2) && (nb_rx==2)) {
@@ -710,6 +750,34 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
 
       break;
 
+  case TS_SHIFT:
+      nb_taps = 2;
+      Td = ts_shift_delays[1];
+      channel_length = 10;
+      ricean_factor = 0.0;
+      aoa = 0.0;
+      maxDoppler = 0;
+
+      fill_channel_desc(chan_desc,nb_tx,
+				   nb_rx,
+				   nb_taps,
+				   channel_length,
+				   ts_shift_amps,
+				   ts_shift_delays,
+				   NULL,
+				   Td,
+				   BW,
+				   ricean_factor,
+				   aoa,
+				   forgetting_factor,
+				   maxDoppler,
+				   channel_offset, 
+				   path_loss_dB,
+				   0);
+      printf("TS_SHIFT: ricean_factor %f\n",chan_desc->ricean_factor);
+
+      break;
+
   case Rice1_corr:
       nb_taps = 1;
       Td = 0;
@@ -779,7 +847,176 @@ channel_desc_t *new_channel_desc_scm(uint8_t nb_tx,
 				   path_loss_dB,
 				   1);
       break;
+      
+  case Rayleigh1_orthogonal:
+      nb_taps = 1;
+      Td = 0;
+      channel_length = 1;
+      ricean_factor = 1;
+      aoa = 0.03;
+      maxDoppler = 0;
+
+      
+      if ((nb_tx==2) && (nb_rx==2)) {
+	R_sqrt_ptr2 = R_sqrt_22_orthogonal;
+      }
+      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,
+				   BW,
+				   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;
+      channel_length = 1;
+      ricean_factor = 1;
+      aoa = 0.03;
+      maxDoppler = 0;
+
+      
+      if ((nb_tx==2) && (nb_rx==2)) {
+	R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_real; 
+      }
+      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,
+				   BW,
+				   ricean_factor,
+				   aoa,
+				   forgetting_factor,
+				   maxDoppler,
+				   channel_offset, 
+				   path_loss_dB,
+				   0);
+      break;
+      
+      case Rayleigh1_orth_eff_ch_TM4_prec_imag:
+      nb_taps = 1;
+      Td = 0;
+      channel_length = 1;
+      ricean_factor = 1;
+      aoa = 0.03;
+      maxDoppler = 0;
+
+      
+      if ((nb_tx==2) && (nb_rx==2)) {
+	R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_imag; 
+      }
+      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,
+				   BW,
+				   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;
+      }
+      else 
+	R_sqrt_ptr2 = NULL;
+
+    
+      nb_taps = 8;
+      Td = 0.8;
+      channel_length = (int)11+2*BW*Td;
+      ricean_factor = 1;
+      aoa = .03;
+      maxDoppler = 0;
+
+      fill_channel_desc(chan_desc,
+			nb_tx,
+			nb_rx,
+			nb_taps,
+			channel_length,
+			default_amps_lin,
+			NULL,
+			R_sqrt_ptr2,
+			Td,
+			BW,
+			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;
+      channel_length = (int)11+2*BW*Td;
+      ricean_factor = 1;
+      aoa = .03;
+      maxDoppler = 0;
+
+      if ((nb_tx==2) && (nb_rx==2)) {
+	R_sqrt_ptr2 = R_sqrt_22_orth_eff_ch_TM4_prec_imag; 
+      }
+      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,
+			BW,
+			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);
@@ -906,6 +1143,11 @@ int random_channel(channel_desc_t *desc, uint8_t abstraction_flag) {
       if (desc->channel_length == 1) {
 	desc->ch[aarx+(aatx*desc->nb_rx)][0].x = desc->a[0][aarx+(aatx*desc->nb_rx)].x;
 	desc->ch[aarx+(aatx*desc->nb_rx)][0].y = desc->a[0][aarx+(aatx*desc->nb_rx)].y;
+#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);
+#endif
+
       }
       else {
 
diff --git a/openair2/UTIL/LOG/log.c b/openair2/UTIL/LOG/log.c
index 7d46648e45d..1a12f4c13ae 100755
--- a/openair2/UTIL/LOG/log.c
+++ b/openair2/UTIL/LOG/log.c
@@ -134,7 +134,7 @@ int logInit (void)
     }
 
     g_log->log_component[PHY].name = "PHY";
-    g_log->log_component[PHY].level = LOG_EMERG;
+    g_log->log_component[PHY].level = LOG_DEBUG;
     g_log->log_component[PHY].flag =  LOG_MED;
     g_log->log_component[PHY].interval =  1;
     g_log->log_component[PHY].fd = 0;
@@ -142,7 +142,7 @@ int logInit (void)
     g_log->log_component[PHY].filelog_name = "/tmp/phy.log";
 
     g_log->log_component[MAC].name = "MAC";
-    g_log->log_component[MAC].level = LOG_EMERG;
+    g_log->log_component[MAC].level = LOG_DEBUG;
     g_log->log_component[MAC].flag =  LOG_MED;
     g_log->log_component[MAC].interval =  1;
     g_log->log_component[MAC].fd = 0;
@@ -150,7 +150,7 @@ int logInit (void)
     g_log->log_component[MAC].filelog_name = "/tmp/mac.log";
 
     g_log->log_component[OPT].name = "OPT";
-    g_log->log_component[OPT].level = LOG_EMERG;
+    g_log->log_component[OPT].level = LOG_DEBUG;
     g_log->log_component[OPT].flag = LOG_MED;
     g_log->log_component[OPT].interval =  1;
     g_log->log_component[OPT].fd = 0;
@@ -158,7 +158,7 @@ int logInit (void)
     g_log->log_component[OPT].filelog_name = "";
 
     g_log->log_component[RLC].name = "RLC";
-    g_log->log_component[RLC].level = LOG_INFO;
+    g_log->log_component[RLC].level = LOG_DEBUG;
     g_log->log_component[RLC].flag = LOG_MED;
     g_log->log_component[RLC].interval =  1;
     g_log->log_component[RLC].fd = 0;
@@ -166,7 +166,7 @@ int logInit (void)
     g_log->log_component[RLC].filelog_name = "/tmp/rlc.log";
 
     g_log->log_component[PDCP].name = "PDCP";
-    g_log->log_component[PDCP].level = LOG_INFO;
+    g_log->log_component[PDCP].level = LOG_DEBUG;
     g_log->log_component[PDCP].flag = LOG_MED;
     g_log->log_component[PDCP].interval =  1;
     g_log->log_component[PDCP].fd = 0;
@@ -174,7 +174,7 @@ int logInit (void)
     g_log->log_component[PDCP].filelog_name = "/tmp/pdcp.log";
 
     g_log->log_component[RRC].name = "RRC";
-    g_log->log_component[RRC].level = LOG_TRACE;
+    g_log->log_component[RRC].level = LOG_DEBUG;
     g_log->log_component[RRC].flag = LOG_MED;
     g_log->log_component[RRC].interval =  1;
     g_log->log_component[RRC].fd = 0;
@@ -182,7 +182,7 @@ int logInit (void)
     g_log->log_component[RRC].filelog_name = "/tmp/rrc.log";
 
     g_log->log_component[NAS].name = "NAS";
-    g_log->log_component[NAS].level = LOG_TRACE;
+    g_log->log_component[NAS].level = LOG_DEBUG;
     g_log->log_component[NAS].flag = LOG_MED;
     g_log->log_component[NAS].interval =  1;
     g_log->log_component[NAS].fd = 0;
@@ -190,7 +190,7 @@ int logInit (void)
     g_log->log_component[NAS].filelog_name = "/tmp/nas.log";
 
     g_log->log_component[EMU].name = "EMU";
-    g_log->log_component[EMU].level = LOG_EMERG;
+    g_log->log_component[EMU].level = LOG_DEBUG;
     g_log->log_component[EMU].flag =  LOG_MED;
     g_log->log_component[EMU].interval =  1;
     g_log->log_component[EMU].fd = 0;
@@ -198,7 +198,7 @@ int logInit (void)
     g_log->log_component[EMU].filelog_name = "";
 
     g_log->log_component[OMG].name = "OMG";
-    g_log->log_component[OMG].level = LOG_EMERG;
+    g_log->log_component[OMG].level = LOG_DEBUG;
     g_log->log_component[OMG].flag =  LOG_MED;
     g_log->log_component[OMG].interval =  1;
     g_log->log_component[OMG].fd = 0;
@@ -206,7 +206,7 @@ int logInit (void)
     g_log->log_component[OMG].filelog_name = "/tmp/omg.csv";
 
     g_log->log_component[OTG].name = "OTG";
-    g_log->log_component[OTG].level = LOG_EMERG;
+    g_log->log_component[OTG].level = LOG_DEBUG;
     g_log->log_component[OTG].flag =  LOG_MED;
     g_log->log_component[OTG].interval =  1;
     g_log->log_component[OTG].fd = 0;
@@ -214,7 +214,7 @@ int logInit (void)
     g_log->log_component[OTG].filelog_name = "/tmp/otg.log";
     
     g_log->log_component[OTG_LATENCY].name = "OTG_LATENCY";
-    g_log->log_component[OTG_LATENCY].level = LOG_EMERG;
+    g_log->log_component[OTG_LATENCY].level = LOG_DEBUG;
     g_log->log_component[OTG_LATENCY].flag =  LOG_MED;
     g_log->log_component[OTG_LATENCY].interval =  1;
     g_log->log_component[OTG_LATENCY].fd = 0;
@@ -222,7 +222,7 @@ int logInit (void)
     g_log->log_component[OTG_LATENCY].filelog_name = "/tmp/otg_latency.dat";
 
     g_log->log_component[OTG_LATENCY_BG].name = "OTG_LATENCY_BG";
-    g_log->log_component[OTG_LATENCY_BG].level = LOG_EMERG;
+    g_log->log_component[OTG_LATENCY_BG].level = LOG_DEBUG;
     g_log->log_component[OTG_LATENCY_BG].flag =  LOG_MED;
     g_log->log_component[OTG_LATENCY_BG].interval =  1;
     g_log->log_component[OTG_LATENCY_BG].fd = 0;
@@ -230,7 +230,7 @@ int logInit (void)
     g_log->log_component[OTG_LATENCY_BG].filelog_name = "/tmp/otg_latency_bg.dat";
 
     g_log->log_component[OTG_GP].name = "OTG_GP";
-    g_log->log_component[OTG_GP].level = LOG_EMERG;
+    g_log->log_component[OTG_GP].level = LOG_DEBUG;
     g_log->log_component[OTG_GP].flag =  LOG_MED;
     g_log->log_component[OTG_GP].interval =  1;
     g_log->log_component[OTG_GP].fd = 0;
@@ -238,7 +238,7 @@ int logInit (void)
     g_log->log_component[OTG_GP].filelog_name = "/tmp/otg_goodput.dat";
 
     g_log->log_component[OTG_GP_BG].name = "OTG_GP_BG";
-    g_log->log_component[OTG_GP_BG].level = LOG_EMERG;
+    g_log->log_component[OTG_GP_BG].level = LOG_DEBUG;
     g_log->log_component[OTG_GP_BG].flag =  LOG_MED;
     g_log->log_component[OTG_GP_BG].interval =  1;
     g_log->log_component[OTG_GP_BG].fd = 0;
@@ -246,7 +246,7 @@ int logInit (void)
     g_log->log_component[OTG_GP_BG].filelog_name = "/tmp/otg_goodput_bg.dat";
 
     g_log->log_component[OTG_JITTER].name = "OTG_JITTER";
-    g_log->log_component[OTG_JITTER].level = LOG_EMERG;
+    g_log->log_component[OTG_JITTER].level = LOG_DEBUG;
     g_log->log_component[OTG_JITTER].flag =  LOG_MED;
     g_log->log_component[OTG_JITTER].interval =  1;
     g_log->log_component[OTG_JITTER].fd = 0;
@@ -254,7 +254,7 @@ int logInit (void)
     g_log->log_component[OTG_JITTER].filelog_name = "/tmp/otg_jitter.dat";
 
     g_log->log_component[OCG].name = "OCG";
-    g_log->log_component[OCG].level = LOG_EMERG;
+    g_log->log_component[OCG].level = LOG_DEBUG;
     g_log->log_component[OCG].flag =  LOG_MED;
     g_log->log_component[OCG].interval =  1;
     g_log->log_component[OCG].fd = 0;
@@ -262,7 +262,7 @@ int logInit (void)
     g_log->log_component[OCG].filelog_name = "";
 
     g_log->log_component[PERF].name = "PERF";
-    g_log->log_component[PERF].level = LOG_EMERG;
+    g_log->log_component[PERF].level = LOG_DEBUG;
     g_log->log_component[PERF].flag =  LOG_MED;
     g_log->log_component[PERF].interval =  1;
     g_log->log_component[PERF].fd = 0;
@@ -270,7 +270,7 @@ int logInit (void)
     g_log->log_component[PERF].filelog_name = "";
 
     g_log->log_component[OIP].name = "OIP";
-    g_log->log_component[OIP].level = LOG_EMERG;
+    g_log->log_component[OIP].level = LOG_DEBUG;
     g_log->log_component[OIP].flag =  LOG_MED;
     g_log->log_component[OIP].interval =  1;
     g_log->log_component[OIP].fd = 0;
@@ -278,7 +278,7 @@ int logInit (void)
     g_log->log_component[OIP].filelog_name = "";
 
     g_log->log_component[CLI].name = "CLI";
-    g_log->log_component[CLI].level = LOG_EMERG;
+    g_log->log_component[CLI].level = LOG_DEBUG;
     g_log->log_component[CLI].flag =  LOG_MED;
     g_log->log_component[CLI].interval =  1;
     g_log->log_component[CLI].fd = 0;
@@ -286,7 +286,7 @@ int logInit (void)
     g_log->log_component[CLI].filelog_name = "";
 
     g_log->log_component[MSC].name = "MSC";
-    g_log->log_component[MSC].level = LOG_EMERG;
+    g_log->log_component[MSC].level = LOG_DEBUG;
     g_log->log_component[MSC].flag =  LOG_MED;
     g_log->log_component[MSC].interval =  1;
     g_log->log_component[MSC].fd = 0;
@@ -294,7 +294,7 @@ int logInit (void)
     g_log->log_component[MSC].filelog_name = "/tmp/msc.log";
 
     g_log->log_component[OCM].name = "OCM";
-    g_log->log_component[OCM].level = LOG_EMERG;
+    g_log->log_component[OCM].level = LOG_DEBUG;
     g_log->log_component[OCM].flag =  LOG_MED;
     g_log->log_component[OCM].interval =  1;
     g_log->log_component[OCM].fd = 0;
@@ -302,7 +302,7 @@ int logInit (void)
     g_log->log_component[OCM].filelog_name = "/tmp/ocm.log";
 
     g_log->log_component[UDP_].name = "UDP";
-    g_log->log_component[UDP_].level = LOG_EMERG;
+    g_log->log_component[UDP_].level = LOG_DEBUG;
     g_log->log_component[UDP_].flag = LOG_FULL;
     g_log->log_component[UDP_].interval = 1;
     g_log->log_component[UDP_].fd = 0;
@@ -310,7 +310,7 @@ int logInit (void)
     g_log->log_component[UDP_].filelog_name = "";
 
     g_log->log_component[GTPU].name = "GTPV1U";
-    g_log->log_component[GTPU].level = LOG_EMERG;
+    g_log->log_component[GTPU].level = LOG_DEBUG;
     g_log->log_component[GTPU].flag = LOG_FULL;
     g_log->log_component[GTPU].interval = 1;
     g_log->log_component[GTPU].fd = 0;
@@ -318,7 +318,7 @@ int logInit (void)
     g_log->log_component[GTPU].filelog_name = "";
 
     g_log->log_component[S1AP].name = "S1AP";
-    g_log->log_component[S1AP].level = LOG_EMERG;
+    g_log->log_component[S1AP].level = LOG_DEBUG;
     g_log->log_component[S1AP].flag = LOG_FULL;
     g_log->log_component[S1AP].interval = 1;
     g_log->log_component[S1AP].fd = 0;
@@ -326,7 +326,7 @@ int logInit (void)
     g_log->log_component[S1AP].filelog_name = "";
 
     g_log->log_component[SCTP].name = "SCTP";
-    g_log->log_component[SCTP].level = LOG_EMERG;
+    g_log->log_component[SCTP].level = LOG_DEBUG;
     g_log->log_component[SCTP].flag = LOG_MED;
     g_log->log_component[SCTP].interval = 1;
     g_log->log_component[SCTP].fd = 0;
@@ -334,7 +334,7 @@ int logInit (void)
     g_log->log_component[SCTP].filelog_name = "";
 
     g_log->log_component[HW].name = "HW";
-    g_log->log_component[HW].level = LOG_EMERG;
+    g_log->log_component[HW].level = LOG_DEBUG;
     g_log->log_component[HW].flag = LOG_MED;
     g_log->log_component[HW].interval = 1;
     g_log->log_component[HW].fd = 0;
@@ -342,7 +342,7 @@ int logInit (void)
     g_log->log_component[HW].filelog_name = "";
 
     g_log->log_component[OSA].name = "OSA";
-    g_log->log_component[OSA].level = LOG_EMERG;
+    g_log->log_component[OSA].level = LOG_DEBUG;
     g_log->log_component[OSA].flag = LOG_MED;
     g_log->log_component[OSA].interval = 1;
     g_log->log_component[OSA].fd = 0;
@@ -350,7 +350,7 @@ int logInit (void)
     g_log->log_component[OSA].filelog_name = "";
 
     g_log->log_component[RAL_ENB].name = "eRAL";
-    g_log->log_component[RAL_ENB].level = LOG_EMERG;
+    g_log->log_component[RAL_ENB].level = LOG_DEBUG;
     g_log->log_component[RAL_ENB].flag = LOG_MED;
     g_log->log_component[RAL_ENB].interval = 1;
     g_log->log_component[RAL_ENB].fd = 0;
@@ -358,7 +358,7 @@ int logInit (void)
     g_log->log_component[RAL_ENB].filelog_name = "";
 
     g_log->log_component[RAL_UE].name = "mRAL";
-    g_log->log_component[RAL_UE].level = LOG_EMERG;
+    g_log->log_component[RAL_UE].level = LOG_DEBUG;
     g_log->log_component[RAL_UE].flag = LOG_MED;
     g_log->log_component[RAL_UE].interval = 1;
     g_log->log_component[RAL_UE].fd = 0;
@@ -366,7 +366,7 @@ int logInit (void)
     g_log->log_component[RAL_UE].filelog_name = "";
 
     g_log->log_component[ENB_APP].name = "ENB_APP";
-    g_log->log_component[ENB_APP].level = LOG_EMERG;
+    g_log->log_component[ENB_APP].level = LOG_DEBUG;
     g_log->log_component[ENB_APP].flag = LOG_MED;
     g_log->log_component[ENB_APP].interval = 1;
     g_log->log_component[ENB_APP].fd = 0;
@@ -374,7 +374,7 @@ int logInit (void)
     g_log->log_component[ENB_APP].filelog_name = "";
 
     g_log->log_component[TMR].name = "TMR";
-    g_log->log_component[TMR].level = LOG_EMERG;
+    g_log->log_component[TMR].level = LOG_DEBUG;
     g_log->log_component[TMR].flag = LOG_MED;
     g_log->log_component[TMR].interval = 1;
     g_log->log_component[TMR].fd = 0;
@@ -391,7 +391,7 @@ int logInit (void)
 
 /* following log component are used for the localization*/    
     g_log->log_component[LOCALIZE].name = "LOCALIZE";
-    g_log->log_component[LOCALIZE].level = LOG_EMERG;
+    g_log->log_component[LOCALIZE].level = LOG_DEBUG;
     g_log->log_component[LOCALIZE].flag =  LOG_MED;
     g_log->log_component[LOCALIZE].interval =  1;
     g_log->log_component[LOCALIZE].fd = 0;
-- 
GitLab