diff --git a/lib_com/options.h b/lib_com/options.h
index 26058933718b7487adaf8fa5f542448d029f97b9..29d23a6cf601a51cb6a9daaedb497da272f464d2 100644
--- a/lib_com/options.h
+++ b/lib_com/options.h
@@ -176,6 +176,7 @@
 #define NONBE_1359_FIX_IVASREND_OMASA_BINAURAL_LOUDNESS /* Nokia: issue 1339: Apply scaling to the object-part of OMASA for binaural rendering in IVAS_rend. */
 #define NONBE_1362_FIX_OMASA_TO_MASA1_RENDERING         /* Nokia: Fix OMASA to MASA1 rendering in IVAS_rend */
 #define NONBE_1360_LFE_DELAY                           /* Dlb: LFE delay alignment when rendering in CLDFB domain*/
+#define	NONBE_SVD_OPTIMIZATION
 
 /* ##################### End NON-BE switches ########################### */
 
diff --git a/lib_dec/ivas_svd_dec.c b/lib_dec/ivas_svd_dec.c
index 1d6282b39c3c34e982694f5ad349413cc5538246..8957c8e060846c7c5473e7c8ce8fb3fd3422a07d 100644
--- a/lib_dec/ivas_svd_dec.c
+++ b/lib_dec/ivas_svd_dec.c
@@ -60,9 +60,17 @@
 
 static float GivensRotation( const float x, const float z );
 
+#ifdef NONBE_SVD_OPTIMIZATION
+static void biDiagonalReductionLeft( float singularVectors[][MAX_OUTPUT_CHANNELS], const int16_t nChannelsL, const int16_t nChannelsC, const int16_t currChannel, float *g );
+#else
 static void biDiagonalReductionLeft( float singularVectors[][MAX_OUTPUT_CHANNELS], float singularValues[MAX_OUTPUT_CHANNELS], float secDiag[MAX_OUTPUT_CHANNELS], const int16_t nChannelsL, const int16_t nChannelsC, const int16_t currChannel, float *sig_x, float *g );
+#endif
 
+#ifdef NONBE_SVD_OPTIMIZATION
+static void biDiagonalReductionRight( float singularVectors[][MAX_OUTPUT_CHANNELS], const int16_t nChannelsL, const int16_t nChannelsC, const int16_t currChannel, float *g );
+#else
 static void biDiagonalReductionRight( float singularVectors[][MAX_OUTPUT_CHANNELS], float secDiag[MAX_OUTPUT_CHANNELS], const int16_t nChannelsL, const int16_t nChannelsC, const int16_t currChannel, float *sig_x, float *g );
+#endif
 
 static void singularVectorsAccumulationLeft( float singularVectors_Left[][MAX_OUTPUT_CHANNELS], float singularValues[MAX_OUTPUT_CHANNELS], const int16_t nChannelsL, const int16_t nChannelsC );
 
@@ -489,13 +497,28 @@ static void HouseholderReduction(
     float *eps_x )
 {
     int16_t nCh;
-    float g = 0.0f, sig_x = 0.0f;
+#ifdef NONBE_SVD_OPTIMIZATION
+    float g_left = 0.0f;
+    float g_right = 0.0f;
+#else
+    float sig_x = 0.0f;
+    float g = 0.0f;
+#endif
+
 
     /* Bidiagonal Reduction for every channel */
     for ( nCh = 0; nCh < nChannelsC; nCh++ ) /* nChannelsC */
     {
+#ifdef NONBE_SVD_OPTIMIZATION
+        secDiag[nCh] = g_right; /* from the previous channel */
+        biDiagonalReductionLeft( singularVectors_Left, nChannelsL, nChannelsC, nCh, &g_left );
+        singularValues[nCh] = g_left;
+        biDiagonalReductionRight( singularVectors_Left, nChannelsL, nChannelsC, nCh, &g_right );
+#else
         biDiagonalReductionLeft( singularVectors_Left, singularValues, secDiag, nChannelsL, nChannelsC, nCh, &sig_x, &g );
         biDiagonalReductionRight( singularVectors_Left, secDiag, nChannelsL, nChannelsC, nCh, &sig_x, &g );
+#endif
+
         *eps_x = max( *eps_x, ( fabsf( singularValues[nCh] ) + fabsf( secDiag[nCh] ) ) );
     }
 
@@ -512,7 +535,58 @@ static void HouseholderReduction(
  *
  *
  *-------------------------------------------------------------------------*/
+#ifdef NONBE_SVD_OPTIMIZATION
+static void biDiagonalReductionLeft(
+    float singularVectors[][MAX_OUTPUT_CHANNELS],
+    const int16_t nChannelsL,
+    const int16_t nChannelsC,
+    const int16_t currChannel,
+    float *g )
+{
+    int16_t iCh, jCh;
+    float norm_x, f, r;
+
+    /* Setting values to 0 */
+    ( *g ) = 0.0f;
+
+    if ( currChannel < nChannelsL ) /* i <= m */
+    {
+        norm_x = 0.0f;
+
 
+        for ( jCh = currChannel; jCh < nChannelsL; jCh++ ) /* nChannelsL */
+        {
+            norm_x += ( singularVectors[jCh][currChannel] * singularVectors[jCh][currChannel] );
+        }
+
+        if ( ( norm_x ) ) /*(fabsf(*sig_x) > EPSILON * fabsf(*sig_x)) { */
+        {
+            ( *g ) = -( singularVectors[currChannel][currChannel] >= 0 ? 1 : ( -1 ) ) * sqrtf( norm_x );
+            r = ( *g ) * singularVectors[currChannel][currChannel] - norm_x;
+            singularVectors[currChannel][currChannel] = ( singularVectors[currChannel][currChannel] - ( *g ) );
+
+            for ( iCh = currChannel + 1; iCh < nChannelsC; iCh++ ) /* nChannelsC */
+            {
+                norm_x = 0.0f;
+                for ( jCh = currChannel; jCh < nChannelsL; jCh++ ) /* nChannelsL */
+                {
+                    norm_x += ( singularVectors[jCh][currChannel] * singularVectors[jCh][iCh] );
+                }
+
+                f = norm_x / maxWithSign( r );
+
+
+                for ( jCh = currChannel; jCh < nChannelsL; jCh++ ) /* nChannelsL */
+                {
+                    singularVectors[jCh][iCh] += ( f * singularVectors[jCh][currChannel] );
+                }
+            }
+        }
+    }
+
+    return;
+}
+#else
 static void biDiagonalReductionLeft(
     float singularVectors[][MAX_OUTPUT_CHANNELS],
     float singularValues[MAX_OUTPUT_CHANNELS],
@@ -583,7 +657,7 @@ static void biDiagonalReductionLeft(
 
     return;
 }
-
+#endif
 
 /*-------------------------------------------------------------------------
  * biDiagonalReductionRight()
@@ -591,6 +665,56 @@ static void biDiagonalReductionLeft(
  *
  *-------------------------------------------------------------------------*/
 
+#ifdef NONBE_SVD_OPTIMIZATION
+static void biDiagonalReductionRight(
+    float singularVectors[][MAX_OUTPUT_CHANNELS],
+    const int16_t nChannelsL,
+    const int16_t nChannelsC,
+    const int16_t currChannel,
+    float *g )
+{
+    int16_t iCh, jCh, idx;
+    float norm_x, r;
+
+    /* Setting values to 0 */
+    ( *g ) = 0.0f;
+
+    if ( currChannel < nChannelsL && currChannel != ( nChannelsC - 1 ) ) /* i <=m && i !=n */
+    {
+        idx = currChannel + 1;
+
+        norm_x = 0.0f;
+
+        for ( jCh = idx; jCh < nChannelsC; jCh++ ) /*nChannelsC */
+        {
+            norm_x += ( singularVectors[currChannel][jCh] * singularVectors[currChannel][jCh] );
+        }
+
+        if ( norm_x ) /*(fabsf(*sig_x) > EPSILON * fabsf(*sig_x)) { */
+        {
+            ( *g ) = -( singularVectors[currChannel][idx] >= 0 ? 1 : ( -1 ) ) * sqrtf( norm_x );
+            r = ( *g ) * singularVectors[currChannel][idx] - norm_x;
+            singularVectors[currChannel][idx] = ( singularVectors[currChannel][idx] - ( *g ) );
+
+            for ( iCh = currChannel + 1; iCh < nChannelsL; iCh++ ) /*  nChannelsL */
+            {
+                norm_x = 0.0f;
+                for ( jCh = idx; jCh < nChannelsC; jCh++ ) /* nChannelsC */
+                {
+                    norm_x += ( singularVectors[iCh][jCh] * singularVectors[currChannel][jCh] );
+                }
+                norm_x /= r;
+                for ( jCh = idx; jCh < nChannelsC; jCh++ ) /*  nChannelsC */
+                {
+                    singularVectors[iCh][jCh] += ( norm_x * singularVectors[currChannel][jCh] );
+                }
+            }
+        }
+    }
+
+    return;
+}
+#else
 static void biDiagonalReductionRight(
     float singularVectors[][MAX_OUTPUT_CHANNELS],
     float secDiag[MAX_OUTPUT_CHANNELS],
@@ -601,6 +725,7 @@ static void biDiagonalReductionRight(
     float *g )
 {
     int16_t iCh, jCh, idx;
+
     float norm_x, r;
 
     /* Setting values to 0 */
@@ -657,7 +782,7 @@ static void biDiagonalReductionRight(
 
     return;
 }
-
+#endif
 
 /*-------------------------------------------------------------------------
  * singularVectorsAccumulationLeft()