diff --git a/srslte/include/srslte/fec/turbodecoder.h b/srslte/include/srslte/fec/turbodecoder.h
index 6a91b6178..9f892d6cc 100644
--- a/srslte/include/srslte/fec/turbodecoder.h
+++ b/srslte/include/srslte/fec/turbodecoder.h
@@ -84,7 +84,7 @@ SRSLTE_API void srslte_tdec_free(srslte_tdec_t * h);
 SRSLTE_API int srslte_tdec_reset(srslte_tdec_t * h, uint32_t long_cb);
 
 SRSLTE_API void srslte_tdec_iteration(srslte_tdec_t * h, 
-                                      float * input, 
+                                      llr_t * input, 
                                       uint32_t long_cb);
 
 SRSLTE_API void srslte_tdec_decision(srslte_tdec_t * h, 
@@ -96,7 +96,7 @@ SRSLTE_API void srslte_tdec_decision_byte(srslte_tdec_t * h,
                                           uint32_t long_cb); 
 
 SRSLTE_API int srslte_tdec_run_all(srslte_tdec_t * h, 
-                                   float * input, 
+                                   llr_t * input, 
                                    uint8_t *output,
                                    uint32_t nof_iterations, 
                                    uint32_t long_cb);
diff --git a/srslte/include/srslte/modem/demod_soft.h b/srslte/include/srslte/modem/demod_soft.h
index 80f63b3b5..d29ffa7f3 100644
--- a/srslte/include/srslte/modem/demod_soft.h
+++ b/srslte/include/srslte/modem/demod_soft.h
@@ -49,6 +49,11 @@ SRSLTE_API int srslte_demod_soft_demodulate(srslte_mod_t modulation,
                                             float* llr, 
                                             int nsymbols); 
 
+SRSLTE_API int srslte_demod_soft_demodulate_s(srslte_mod_t modulation, 
+                                              const cf_t* symbols, 
+                                              short* llr, 
+                                              int nsymbols); 
+
 /* High-level API */
 typedef struct SRSLTE_API {
   srslte_modem_table_t table;
diff --git a/srslte/lib/fec/src/turbodecoder.c b/srslte/lib/fec/src/turbodecoder.c
index a9ddd7d4c..b906f5aa4 100644
--- a/srslte/lib/fec/src/turbodecoder.c
+++ b/srslte/lib/fec/src/turbodecoder.c
@@ -47,22 +47,6 @@
 
 #define INF 10000
 #define ZERO 0
-#define SCALE 100
-
-static void print128_num(__m128i var)
-{
-    int16_t *val = (int16_t*) &var;//can also use uint32_t instead of 16_t
-    printf("[%d %d %d %d %d %d %d %d]\n", 
-           val[0], val[1], val[2], val[3], val[4], val[5], 
-           val[6], val[7]);
-}
-
-void print128f_num(__m128 var)
-{
-    float *val = (float*) &var;
-    printf("[%f %f %f %f]\n", 
-           val[0], val[1], val[2], val[3]);
-}
 
 
 /************************************************
@@ -434,11 +418,10 @@ void srslte_tdec_free(srslte_tdec_t * h)
   bzero(h, sizeof(srslte_tdec_t));
 }
 
-void deinterleave_input(srslte_tdec_t *h, float *input, uint32_t long_cb) {
+void deinterleave_input(srslte_tdec_t *h, short *input, uint32_t long_cb) {
   uint32_t i;
  
-  float *inputPtr = input; 
-  __m128 inf0, inf1, inf2, inf3, inf4, inf5;
+  __m128i *inputPtr = (__m128i*) input; 
   __m128i in0, in1, in2;
   __m128i s0, s1, s2, s;
   __m128i p00, p01, p02, p0;
@@ -468,30 +451,14 @@ void deinterleave_input(srslte_tdec_t *h, float *input, uint32_t long_cb) {
   __m128i p11_mask = _mm_set_epi8(0xff,0xff,0xff,0xff,0xff,0xff,13,12,7,6,1,0,0xff,0xff,0xff,0xff);
   // pick bits 1, 4, 7 from 3rd word
   __m128i p12_mask = _mm_set_epi8(15,14,9,8,3,2,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
-  
-  __m128 vScalar = _mm_set1_ps(SCALE);
-    
+      
   // Split systematic and parity bits
   for (i = 0; i < long_cb/8; i++) {
         
-    inf0 = _mm_load_ps(inputPtr); inputPtr+=4; 
-    inf1 = _mm_load_ps(inputPtr); inputPtr+=4;   
-    inf2 = _mm_load_ps(inputPtr); inputPtr+=4;
-    inf3 = _mm_load_ps(inputPtr); inputPtr+=4;
-    inf4 = _mm_load_ps(inputPtr); inputPtr+=4;
-    inf5 = _mm_load_ps(inputPtr); inputPtr+=4;
-
-    inf0 = _mm_mul_ps(inf0, vScalar);
-    inf1 = _mm_mul_ps(inf1, vScalar);
-    inf2 = _mm_mul_ps(inf2, vScalar);
-    inf3 = _mm_mul_ps(inf3, vScalar);
-    inf4 = _mm_mul_ps(inf4, vScalar);
-    inf5 = _mm_mul_ps(inf5, vScalar);
+    in0 = _mm_load_si128(inputPtr); inputPtr++; 
+    in1 = _mm_load_si128(inputPtr); inputPtr++;   
+    in2 = _mm_load_si128(inputPtr); inputPtr++;
     
-    in0 = _mm_packs_epi32(_mm_cvtps_epi32(inf0), _mm_cvtps_epi32(inf1));
-    in1 = _mm_packs_epi32(_mm_cvtps_epi32(inf2), _mm_cvtps_epi32(inf3));
-    in2 = _mm_packs_epi32(_mm_cvtps_epi32(inf4), _mm_cvtps_epi32(inf5));
-
     /* Deinterleave Systematic bits */
     s0 = _mm_shuffle_epi8(in0, s0_mask);
     s1 = _mm_shuffle_epi8(in1, s1_mask);
@@ -525,17 +492,17 @@ void deinterleave_input(srslte_tdec_t *h, float *input, uint32_t long_cb) {
   }
   
   for (i = 0; i < 3; i++) {
-    h->syst[i+long_cb]    = (llr_t) SCALE*input[3*long_cb + 2*i];
-    h->parity0[i+long_cb] = (llr_t) SCALE*input[3*long_cb + 2*i + 1];
+    h->syst[i+long_cb]    = input[3*long_cb + 2*i];
+    h->parity0[i+long_cb] = input[3*long_cb + 2*i + 1];
   }
   for (i = 0; i < 3; i++) {
-    h->app2[i+long_cb]    = (llr_t) SCALE*input[3*long_cb + 6 + 2*i];
-    h->parity1[i+long_cb] = (llr_t) SCALE*input[3*long_cb + 6 + 2*i + 1];
+    h->app2[i+long_cb]    = input[3*long_cb + 6 + 2*i];
+    h->parity1[i+long_cb] = input[3*long_cb + 6 + 2*i + 1];
   }
 
 }
 
-void srslte_tdec_iteration(srslte_tdec_t * h, float * input, uint32_t long_cb)
+void srslte_tdec_iteration(srslte_tdec_t * h, short * input, uint32_t long_cb)
 {
 
   if (h->current_cbidx >= 0) {
@@ -639,7 +606,7 @@ void srslte_tdec_decision_byte(srslte_tdec_t * h, uint8_t *output, uint32_t long
   }
 }
 
-int srslte_tdec_run_all(srslte_tdec_t * h, float * input, uint8_t *output,
+int srslte_tdec_run_all(srslte_tdec_t * h, short * input, uint8_t *output,
                   uint32_t nof_iterations, uint32_t long_cb)
 {
   if (srslte_tdec_reset(h, long_cb)) {
diff --git a/srslte/lib/fec/test/turbodecoder_test.c b/srslte/lib/fec/test/turbodecoder_test.c
index 21c55869b..a9d3be2b9 100644
--- a/srslte/lib/fec/test/turbodecoder_test.c
+++ b/srslte/lib/fec/test/turbodecoder_test.c
@@ -112,6 +112,7 @@ void parse_args(int argc, char **argv) {
 int main(int argc, char **argv) {
   uint32_t frame_cnt;
   float *llr;
+  short *llr_s;
   uint8_t *llr_c;
   uint8_t *data_tx, *data_rx, *data_rx_bytes, *symbols;
   uint32_t i, j;
@@ -173,6 +174,11 @@ int main(int argc, char **argv) {
     perror("malloc");
     exit(-1);
   }
+  llr_s = srslte_vec_malloc(coded_length * sizeof(short));
+  if (!llr_s) {
+    perror("malloc");
+    exit(-1);
+  }
   llr_c = srslte_vec_malloc(coded_length * sizeof(uint8_t));
   if (!llr_c) {
     perror("malloc");
@@ -239,7 +245,10 @@ int main(int argc, char **argv) {
       }
 
       srslte_ch_awgn_f(llr, llr, var[i], coded_length);
-      
+
+      for (j=0;j<coded_length;j++) {
+        llr_s[j] = (int16_t) (100*llr[j]);
+      }
       /* decoder */
       srslte_tdec_reset(&tdec, frame_length);
       srslte_tdec_vl_reset(&tdec_vl, frame_length);
@@ -253,7 +262,7 @@ int main(int argc, char **argv) {
 
       gettimeofday(&tdata[1], NULL); 
       for (int k=0;k<nof_repetitions;k++) {     
-        srslte_tdec_run_all(&tdec, llr, data_rx_bytes, t, frame_length);        
+        srslte_tdec_run_all(&tdec, llr_s, data_rx_bytes, t, frame_length);        
       }
       gettimeofday(&tdata[2], NULL);
       get_time_interval(tdata);
@@ -262,7 +271,7 @@ int main(int argc, char **argv) {
       srslte_bit_unpack_vector(data_rx_bytes, data_rx, frame_length);
 
       errors += srslte_bit_diff(data_tx, data_rx, frame_length);
-      
+
       gettimeofday(&tdata[1], NULL); 
       for (int k=0;k<nof_repetitions;k++) {     
         srslte_tdec_vl_run_all(&tdec_vl, llr, data_rx, t, frame_length);
diff --git a/srslte/lib/modem/src/demod_soft.c b/srslte/lib/modem/src/demod_soft.c
index a89a6734e..34c704b44 100644
--- a/srslte/lib/modem/src/demod_soft.c
+++ b/srslte/lib/modem/src/demod_soft.c
@@ -33,8 +33,23 @@
 #include "srslte/utils/bit.h"
 #include "srslte/modem/demod_soft.h"
 
+#define HAVE_SIMD
+
+#ifdef HAVE_SIMD
+#include <xmmintrin.h>
+#include <tmmintrin.h>
+#endif
+
+
 //#define SCALE_DEMOD16QAM
 
+#define SCALE_SHORT_CONV 100
+
+void demod_bpsk_lte_s(const cf_t *symbols, short *llr, int nsymbols) {
+  for (int i=0;i<nsymbols;i++) {
+    llr[i] = (short) -SCALE_SHORT_CONV*(crealf(symbols[i]) + cimagf(symbols[i]))/sqrt(2);
+  }
+}
 
 void demod_bpsk_lte(const cf_t *symbols, float *llr, int nsymbols) {
   for (int i=0;i<nsymbols;i++) {
@@ -42,6 +57,11 @@ void demod_bpsk_lte(const cf_t *symbols, float *llr, int nsymbols) {
   }
 }
 
+void demod_qpsk_lte_s(const cf_t *symbols, short *llr, int nsymbols) {
+  srslte_vec_fprint_f(stdout, (float*) symbols, nsymbols*2);
+  srslte_vec_convert_fi((float*) symbols, llr, -SCALE_SHORT_CONV*sqrt(2), nsymbols*2);
+}
+
 void demod_qpsk_lte(const cf_t *symbols, float *llr, int nsymbols) {
   srslte_vec_sc_prod_fff((float*) symbols, -sqrt(2), llr, nsymbols*2);
 }
@@ -79,6 +99,62 @@ void demod_16qam_lte(const cf_t *symbols, float *llr, int nsymbols) {
   }
 }
 
+void demod_16qam_lte_s(const cf_t *symbols, short *llr, int nsymbols) {
+#ifndef HAVE_SIMD
+  for (int i=0;i<nsymbols;i++) {
+    short yre = (short) (SCALE_SHORT_CONV*crealf(symbols[i]));
+    short yim = (short) (SCALE_SHORT_CONV*cimagf(symbols[i]));
+        
+    llr[4*i+0] = -yre;
+    llr[4*i+1] = -yim;
+    llr[4*i+2] = abs(yre)-2*SCALE_SHORT_CONV/sqrt(10);
+    llr[4*i+3] = abs(yim)-2*SCALE_SHORT_CONV/sqrt(10);    
+  }
+#else
+
+  float *symbolsPtr = (float*) symbols;
+  __m128i *resultPtr = (__m128i*) llr;
+  __m128 symbol1, symbol2; 
+  __m128i symbol_i1, symbol_i2, symbol_i, symbol_abs;
+  __m128i offset = _mm_set1_epi16(2*SCALE_SHORT_CONV/sqrt(10));
+  __m128i result11, result12, result22, result21; 
+  __m128 scale_v = _mm_set1_ps(-SCALE_SHORT_CONV);
+  __m128i shuffle_negated_1 = _mm_set_epi8(0xff,0xff,0xff,0xff,7,6,5,4,0xff,0xff,0xff,0xff,3,2,1,0);
+  __m128i shuffle_negated_2 = _mm_set_epi8(0xff,0xff,0xff,0xff,15,14,13,12,0xff,0xff,0xff,0xff,11,10,9,8);
+  __m128i shuffle_abs_1 = _mm_set_epi8(7,6,5,4,0xff,0xff,0xff,0xff,3,2,1,0,0xff,0xff,0xff,0xff);
+  __m128i shuffle_abs_2 = _mm_set_epi8(15,14,13,12,0xff,0xff,0xff,0xff,11,10,9,8,0xff,0xff,0xff,0xff);
+  for (int i=0;i<nsymbols/4;i++) {
+    symbol1   = _mm_load_ps(symbolsPtr); symbolsPtr+=4;
+    symbol2   = _mm_load_ps(symbolsPtr); symbolsPtr+=4;
+    symbol_i1 = _mm_cvtps_epi32(_mm_mul_ps(symbol1, scale_v));
+    symbol_i2 = _mm_cvtps_epi32(_mm_mul_ps(symbol2, scale_v));
+    symbol_i  = _mm_packs_epi32(symbol_i1, symbol_i2);
+    
+    symbol_abs  = _mm_abs_epi16(symbol_i);
+    symbol_abs  = _mm_sub_epi16(symbol_abs, offset);
+    
+    result11 = _mm_shuffle_epi8(symbol_i, shuffle_negated_1);  
+    result12 = _mm_shuffle_epi8(symbol_abs, shuffle_abs_1);  
+
+    result21 = _mm_shuffle_epi8(symbol_i, shuffle_negated_2);  
+    result22 = _mm_shuffle_epi8(symbol_abs, shuffle_abs_2);  
+
+    _mm_store_si128(resultPtr, _mm_or_si128(result11, result12)); resultPtr++;
+    _mm_store_si128(resultPtr, _mm_or_si128(result21, result22)); resultPtr++;
+  }
+  // Demodulate last symbols 
+  for (int i=4*(nsymbols/4);i<nsymbols;i++) {
+    short yre = (short) (SCALE_SHORT_CONV*crealf(symbols[i]));
+    short yim = (short) (SCALE_SHORT_CONV*cimagf(symbols[i]));
+        
+    llr[4*i+0] = -yre;
+    llr[4*i+1] = -yim;
+    llr[4*i+2] = abs(yre)-2*SCALE_SHORT_CONV/sqrt(10);
+    llr[4*i+3] = abs(yim)-2*SCALE_SHORT_CONV/sqrt(10);    
+  }
+#endif
+}
+
 void demod_64qam_lte(const cf_t *symbols, float *llr, int nsymbols) 
 {
   for (int i=0;i<nsymbols;i++) {
@@ -95,6 +171,83 @@ void demod_64qam_lte(const cf_t *symbols, float *llr, int nsymbols)
   
 }
 
+void demod_64qam_lte_s(const cf_t *symbols, short *llr, int nsymbols) 
+{
+#ifndef HAVE_SIMD
+  for (int i=0;i<nsymbols;i++) {
+    float yre = (short) (SCALE_SHORT_CONV*crealf(symbols[i]));
+    float yim = (short) (SCALE_SHORT_CONV*cimagf(symbols[i]));
+
+    llr[6*i+0] = -yre;
+    llr[6*i+1] = -yim;
+    llr[6*i+2] = abs(yre)-4*SCALE_SHORT_CONV/sqrt(42);
+    llr[6*i+3] = abs(yim)-4*SCALE_SHORT_CONV/sqrt(42);
+    llr[6*i+4] = abs(llr[6*i+2])-2*SCALE_SHORT_CONV/sqrt(42);
+    llr[6*i+5] = abs(llr[6*i+3])-2*SCALE_SHORT_CONV/sqrt(42);        
+  }
+#else
+  float *symbolsPtr = (float*) symbols;
+  __m128i *resultPtr = (__m128i*) llr;
+  __m128 symbol1, symbol2; 
+  __m128i symbol_i1, symbol_i2, symbol_i, symbol_abs, symbol_abs2;
+  __m128i offset1 = _mm_set1_epi16(4*SCALE_SHORT_CONV/sqrt(42));
+  __m128i offset2 = _mm_set1_epi16(2*SCALE_SHORT_CONV/sqrt(42));
+  __m128 scale_v = _mm_set1_ps(-SCALE_SHORT_CONV);
+  __m128i result11, result12, result13, result22, result21,result23, result31, result32, result33; 
+
+  __m128i shuffle_negated_1 = _mm_set_epi8(7,6,5,4,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,3,2,1,0);
+  __m128i shuffle_negated_2 = _mm_set_epi8(0xff,0xff,0xff,0xff,11,10,9,8,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
+  __m128i shuffle_negated_3 = _mm_set_epi8(0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,15,14,13,12,0xff,0xff,0xff,0xff);
+
+  __m128i shuffle_abs_1 = _mm_set_epi8(0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,3,2,1,0,0xff,0xff,0xff,0xff);
+  __m128i shuffle_abs_2 = _mm_set_epi8(11,10,9,8,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,7,6,5,4);
+  __m128i shuffle_abs_3 = _mm_set_epi8(0xff,0xff,0xff,0xff,15,14,13,12,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
+
+  __m128i shuffle_abs2_1 = _mm_set_epi8(0xff,0xff,0xff,0xff,3,2,1,0,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff);
+  __m128i shuffle_abs2_2 = _mm_set_epi8(0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,7,6,5,4,0xff,0xff,0xff,0xff);
+  __m128i shuffle_abs2_3 = _mm_set_epi8(15,14,13,12,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,11,10,9,8);
+
+  for (int i=0;i<nsymbols/4;i++) {
+    symbol1   = _mm_load_ps(symbolsPtr); symbolsPtr+=4;
+    symbol2   = _mm_load_ps(symbolsPtr); symbolsPtr+=4;
+    symbol_i1 = _mm_cvtps_epi32(_mm_mul_ps(symbol1, scale_v));
+    symbol_i2 = _mm_cvtps_epi32(_mm_mul_ps(symbol2, scale_v));
+    symbol_i  = _mm_packs_epi32(symbol_i1, symbol_i2);
+    
+    symbol_abs  = _mm_abs_epi16(symbol_i);
+    symbol_abs  = _mm_sub_epi16(symbol_abs, offset1);
+    symbol_abs2 = _mm_sub_epi16(_mm_abs_epi16(symbol_abs), offset2);
+    
+    result11 = _mm_shuffle_epi8(symbol_i, shuffle_negated_1);  
+    result12 = _mm_shuffle_epi8(symbol_abs, shuffle_abs_1);  
+    result13 = _mm_shuffle_epi8(symbol_abs2, shuffle_abs2_1);  
+
+    result21 = _mm_shuffle_epi8(symbol_i, shuffle_negated_2);  
+    result22 = _mm_shuffle_epi8(symbol_abs, shuffle_abs_2);  
+    result23 = _mm_shuffle_epi8(symbol_abs2, shuffle_abs2_2);  
+
+    result31 = _mm_shuffle_epi8(symbol_i, shuffle_negated_3);  
+    result32 = _mm_shuffle_epi8(symbol_abs, shuffle_abs_3);  
+    result33 = _mm_shuffle_epi8(symbol_abs2, shuffle_abs2_3);  
+
+    _mm_store_si128(resultPtr, _mm_or_si128(_mm_or_si128(result11, result12),result13)); resultPtr++;
+    _mm_store_si128(resultPtr, _mm_or_si128(_mm_or_si128(result21, result22),result23)); resultPtr++;
+    _mm_store_si128(resultPtr, _mm_or_si128(_mm_or_si128(result31, result32),result33)); resultPtr++;
+  }
+  for (int i=4*(nsymbols/4);i<nsymbols;i++) {
+    float yre = (short) (SCALE_SHORT_CONV*crealf(symbols[i]));
+    float yim = (short) (SCALE_SHORT_CONV*cimagf(symbols[i]));
+
+    llr[6*i+0] = -yre;
+    llr[6*i+1] = -yim;
+    llr[6*i+2] = abs(yre)-4*SCALE_SHORT_CONV/sqrt(42);
+    llr[6*i+3] = abs(yim)-4*SCALE_SHORT_CONV/sqrt(42);
+    llr[6*i+4] = abs(llr[6*i+2])-2*SCALE_SHORT_CONV/sqrt(42);
+    llr[6*i+5] = abs(llr[6*i+3])-2*SCALE_SHORT_CONV/sqrt(42);        
+  }
+#endif
+}
+
 int srslte_demod_soft_demodulate(srslte_mod_t modulation, const cf_t* symbols, float* llr, int nsymbols) {
   switch(modulation) {
     case SRSLTE_MOD_BPSK:
@@ -116,6 +269,27 @@ int srslte_demod_soft_demodulate(srslte_mod_t modulation, const cf_t* symbols, f
   return 0; 
 }
 
+int srslte_demod_soft_demodulate_s(srslte_mod_t modulation, const cf_t* symbols, short* llr, int nsymbols) {
+  switch(modulation) {
+    case SRSLTE_MOD_BPSK:
+      demod_bpsk_lte_s(symbols, llr, nsymbols);
+      break;
+    case SRSLTE_MOD_QPSK:
+      demod_qpsk_lte_s(symbols, llr, nsymbols);
+      break;
+    case SRSLTE_MOD_16QAM:
+      demod_16qam_lte_s(symbols, llr, nsymbols);
+      break;
+    case SRSLTE_MOD_64QAM:
+      demod_64qam_lte_s(symbols, llr, nsymbols);
+      break;
+    default: 
+      fprintf(stderr, "Invalid modulation %d\n", modulation);
+      return -1; 
+  } 
+  return 0; 
+}
+
 
 /* High-Level API */
 int srslte_demod_soft_initialize(srslte_demod_soft_hl* hl) {
diff --git a/srslte/lib/modem/test/soft_demod_test.c b/srslte/lib/modem/test/soft_demod_test.c
index e69026b55..70633e3fb 100644
--- a/srslte/lib/modem/test/soft_demod_test.c
+++ b/srslte/lib/modem/test/soft_demod_test.c
@@ -112,6 +112,7 @@ int main(int argc, char **argv) {
   uint8_t *input, *output;
   cf_t *symbols;
   float *llr;
+  short *llr_s;
 
   parse_args(argc, argv);
 
@@ -125,34 +126,41 @@ int main(int argc, char **argv) {
   num_bits = mod.nbits_x_symbol * (num_bits / mod.nbits_x_symbol);
 
   /* allocate buffers */
-  input = malloc(sizeof(uint8_t) * num_bits);
+  input = srslte_vec_malloc(sizeof(uint8_t) * num_bits);
   if (!input) {
     perror("malloc");
     exit(-1);
   }
-  output = malloc(sizeof(uint8_t) * num_bits);
+  output = srslte_vec_malloc(sizeof(uint8_t) * num_bits);
   if (!output) {
     perror("malloc");
     exit(-1);
   }
-  symbols = malloc(sizeof(cf_t) * num_bits / mod.nbits_x_symbol);
+  symbols = srslte_vec_malloc(sizeof(cf_t) * num_bits / mod.nbits_x_symbol);
   if (!symbols) {
     perror("malloc");
     exit(-1);
   }
 
-  llr = malloc(sizeof(float) * num_bits);
+  llr = srslte_vec_malloc(sizeof(float) * num_bits);
   if (!llr) {
     perror("malloc");
     exit(-1);
   }
 
+  llr_s = srslte_vec_malloc(sizeof(short) * num_bits);
+  if (!llr_s) {
+    perror("malloc");
+    exit(-1);
+  }
+
   /* generate random data */
   srand(0);
   
   int ret = -1;
   struct timeval t[3]; 
   float mean_texec = 0.0; 
+  float mean_texec_s = 0.0; 
   for (int n=0;n<nof_frames;n++) {
     for (i=0;i<num_bits;i++) {
       input[i] = rand()%2;
@@ -165,11 +173,20 @@ int main(int argc, char **argv) {
     srslte_demod_soft_demodulate(modulation, symbols, llr, num_bits / mod.nbits_x_symbol);
     gettimeofday(&t[2], NULL);
     get_time_interval(t);
-    
+
     /* compute exponentially averaged execution time */
     if (n > 0) {
       mean_texec = SRSLTE_VEC_CMA((float) t[0].tv_usec, mean_texec, n-1);      
     }
+
+    gettimeofday(&t[1], NULL);
+    srslte_demod_soft_demodulate_s(modulation, symbols, llr_s, num_bits / mod.nbits_x_symbol);
+    gettimeofday(&t[2], NULL);
+    get_time_interval(t);
+
+    if (n > 0) {
+      mean_texec_s = SRSLTE_VEC_CMA((float) t[0].tv_usec, mean_texec_s, n-1);      
+    }
     
     if (SRSLTE_VERBOSE_ISDEBUG()) {
       printf("bits=");
@@ -180,6 +197,10 @@ int main(int argc, char **argv) {
 
       printf("llr=");
       srslte_vec_fprint_f(stdout, llr, num_bits);
+
+      printf("llr_s=");
+      srslte_vec_fprint_s(stdout, llr_s, num_bits);
+
     }
 
     // Check demodulation errors
@@ -200,6 +221,7 @@ clean_exit:
 
   srslte_modem_table_free(&mod);
 
-  printf("Mean Throughput: %.2f. Mbps ExTime: %.2f us\n", num_bits/mean_texec, mean_texec);    
+  printf("Mean Throughput: %.2f/%.2f. Mbps ExTime: %.2f/%.2f us\n", 
+         num_bits/mean_texec, num_bits/mean_texec_s, mean_texec, mean_texec_s);    
   exit(ret);
 }
diff --git a/srslte/lib/utils/src/vector_simd.c b/srslte/lib/utils/src/vector_simd.c
index f979b6e2a..d62fe75f9 100644
--- a/srslte/lib/utils/src/vector_simd.c
+++ b/srslte/lib/utils/src/vector_simd.c
@@ -168,35 +168,31 @@ void srslte_vec_lut_sss_simd(short *x, unsigned short *lut, short *y, uint32_t l
 /* Modified from volk_32f_s32f_convert_16i_a_sse2. Removed clipping */
 void srslte_vec_convert_fi_simd(float *x, int16_t *z, float scale, uint32_t len)
 {
-    unsigned int number = 0;
+  unsigned int number = 0;
 
   const unsigned int eighthPoints = len / 8;
 
   const float* inputVectorPtr = (const float*)x;
   int16_t* outputVectorPtr = z;
 
-  float min_val = -32768;
-  float max_val = 32767;
-  float r;
-
   __m128 vScalar = _mm_set_ps1(scale);
   __m128 inputVal1, inputVal2;
   __m128i intInputVal1, intInputVal2;
   __m128 ret1, ret2;
-  __m128 vmin_val = _mm_set_ps1(min_val);
-  __m128 vmax_val = _mm_set_ps1(max_val);
 
   for(;number < eighthPoints; number++){
     inputVal1 = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;
     inputVal2 = _mm_load_ps(inputVectorPtr); inputVectorPtr += 4;
 
-    // Scale and clip
     ret1 = _mm_mul_ps(inputVal1, vScalar);
     ret2 = _mm_mul_ps(inputVal2, vScalar);
 
     intInputVal1 = _mm_cvtps_epi32(ret1);
     intInputVal2 = _mm_cvtps_epi32(ret2);
 
+    printf("intinput: "); print128_num(intInputVal1);
+    printf("intinput2: "); print128_num(intInputVal2);
+
     intInputVal1 = _mm_packs_epi32(intInputVal1, intInputVal2);
 
     _mm_store_si128((__m128i*)outputVectorPtr, intInputVal1);
@@ -204,13 +200,8 @@ void srslte_vec_convert_fi_simd(float *x, int16_t *z, float scale, uint32_t len)
   }
 
   number = eighthPoints * 8;
-  for(; number < num_points; number++){
-    r = inputVector[number] * scalar;
-    if(r > max_val)
-      r = max_val;
-    else if(r < min_val)
-      r = min_val;
-    outputVector[number] = (int16_t)rintf(r);
+  for(; number < len; number++){
+    z[number] = (int16_t) (x[number] * scale);
   }
 
 }
\ No newline at end of file