diff --git a/README.md b/README.md
index 05ed941ea..f7dd9bd24 100644
--- a/README.md
+++ b/README.md
@@ -69,6 +69,7 @@ In order to run the highest resolution supported by the encoder, at least 64GB o
     - Download the yasm exe from the following [link](http://www.tortall.net/projects/yasm/releases/yasm-1.3.0-win64.exe)
     - Rename yasm-1.3.0-win64.exe to yasm.exe
     - Copy yasm.exe into a location that is in the PATH environment variable
+    - Vnni requires gcc version >= 9.2.
 
 - __Build Instructions__
   - Build the project by following the steps below in a windows command prompt:
diff --git a/Source/Lib/ASM_AVX2/CMakeLists.txt b/Source/Lib/ASM_AVX2/CMakeLists.txt
index 9705a8adc..28389ee58 100644
--- a/Source/Lib/ASM_AVX2/CMakeLists.txt
+++ b/Source/Lib/ASM_AVX2/CMakeLists.txt
@@ -17,7 +17,10 @@ link_directories(${PROJECT_SOURCE_DIR}/Source/Lib/ASM_SSSE3/)
 
 set(flags_to_test
     -mavx2
-    -static-intel
+    -mavx512bw
+    -mavx512vnni
+    -mavx512vl   
+    -static-intel 
     /Qwd10148
     /Qwd10010
     /Qwd10157)
diff --git a/Source/Lib/ASM_AVX2/EbComputeSAD_SadLoopKernel_AVX512.c b/Source/Lib/ASM_AVX2/EbComputeSAD_SadLoopKernel_AVX512.c
index 1d530b724..25cad707a 100644
--- a/Source/Lib/ASM_AVX2/EbComputeSAD_SadLoopKernel_AVX512.c
+++ b/Source/Lib/ASM_AVX2/EbComputeSAD_SadLoopKernel_AVX512.c
@@ -209,6 +209,8 @@ void SadLoopKernel_AVX512_HmeL0_INTRIN(
 
 	case 16:
 	{
+				__m512i x = _mm512_setr_epi64(0x0000000000000000, 0x0001000100010001, 0x0004000400040004, 0x0005000500050005, 0x0001000100010001, 0x0002000200020002, 0x0005000500050005, 0x0006000600060006);
+				__m512i x1 = _mm512_setr_epi64(0x0001000100010001, 0x0002000200020002, 0x0005000500050005, 0x0006000600060006, 0x0002000200020002, 0x0003000300030003, 0x0006000600060006, 0x0007000700070007);			
 				if (height <= 16 && searchAreaWidth <= 128)
 				{
 					for (i = 0; i<searchAreaHeight; i++) 
@@ -243,17 +245,18 @@ void SadLoopKernel_AVX512_HmeL0_INTRIN(
 
 							for (j = 0, pRef = pRef1; j < n; j++, pRef += 16) 
 							{
-								__m256i ss0 = _mm256_inserti128_si256(_mm256_castsi128_si256(_mm_loadu_si128((__m128i*)(pRef     ))), _mm_loadu_si128((__m128i*)(pRef + refStride     )), 0x1);
-								__m256i ss1 = _mm256_inserti128_si256(_mm256_castsi128_si256(_mm_loadu_si128((__m128i*)(pRef + 8 ))), _mm_loadu_si128((__m128i*)(pRef + refStride + 8 )), 0x1);
-										ss2 = _mm256_inserti128_si256(_mm256_castsi128_si256(_mm_loadu_si128((__m128i*)(pRef + 16))), _mm_loadu_si128((__m128i*)(pRef + refStride + 16)), 0x1);
-
-								__m512i ss1ftemp = _mm512_inserti64x4(_mm512_castsi256_si512(ss0), ss1, 0x1);
-								__m512i ss2ftemp = _mm512_inserti64x4(_mm512_castsi256_si512(ss1), ss2, 0x1);
-
-								ss3sum1_aaray[j] = _mm512_adds_epu16(ss3sum1_aaray[j], _mm512_dbsad_epu8(ref1ftemp, ss1ftemp, 0x94));
-								ss3sum1_aaray[j] = _mm512_adds_epu16(ss3sum1_aaray[j], _mm512_dbsad_epu8(ref2ftemp, ss1ftemp, 0xE9));
-								ss7sum1_aaray[j] = _mm512_adds_epu16(ss7sum1_aaray[j], _mm512_dbsad_epu8(ref3ftemp, ss2ftemp, 0x94));
-								ss7sum1_aaray[j] = _mm512_adds_epu16(ss7sum1_aaray[j], _mm512_dbsad_epu8(ref4ftemp, ss2ftemp, 0xE9));
+								__m512i ss0 = _mm512_inserti64x4(_mm512_castsi256_si512(_mm256_loadu_si256((__m256i*)(pRef))), _mm256_loadu_si256((__m256i*)(pRef + refStride )), 0x1);
+								__m512i ss1ftemp = _mm512_permutexvar_epi64(x, ss0);
+								__m512i ss2ftemp = _mm512_permutexvar_epi64(x1, ss0);
+								__m512i temp = ss3sum1_aaray[j];
+								__m512i temp1 = ss7sum1_aaray[j];
+
+								temp = _mm512_adds_epu16(temp, _mm512_dbsad_epu8(ref1ftemp, ss1ftemp, 0x94));
+								temp = _mm512_adds_epu16(temp, _mm512_dbsad_epu8(ref2ftemp, ss1ftemp, 0xE9));
+								temp1 = _mm512_adds_epu16(temp1, _mm512_dbsad_epu8(ref3ftemp, ss2ftemp, 0x94));
+								temp1 = _mm512_adds_epu16(temp1, _mm512_dbsad_epu8(ref4ftemp, ss2ftemp, 0xE9));
+								ss3sum1_aaray[j] = temp;
+								ss7sum1_aaray[j] = temp1;								
 
 							}
 
diff --git a/Source/Lib/ASM_AVX2/EbTransforms_AVX2.h b/Source/Lib/ASM_AVX2/EbTransforms_AVX2.h
index 30be3e941..e172f16af 100644
--- a/Source/Lib/ASM_AVX2/EbTransforms_AVX2.h
+++ b/Source/Lib/ASM_AVX2/EbTransforms_AVX2.h
@@ -11,6 +11,14 @@
 extern "C" {
 #endif
 
+#ifdef VNNI_SUPPORT
+#define EbHevcTransform32_INTRIN EbHevcTransform32_VNNI_INTRIN
+#else 
+#define EbHevcTransform32_INTRIN EbHevcTransform32_AVX2_INTRIN
+#endif
+
+
+
 void QuantizeInvQuantize8x8_AVX2_INTRIN(
 	EB_S16          *coeff,
 	const EB_U32     coeffStride,
diff --git a/Source/Lib/ASM_AVX2/EbTransforms_Intrinsic_AVX2.c b/Source/Lib/ASM_AVX2/EbTransforms_Intrinsic_AVX2.c
index 9804d1984..d4662b08b 100644
--- a/Source/Lib/ASM_AVX2/EbTransforms_Intrinsic_AVX2.c
+++ b/Source/Lib/ASM_AVX2/EbTransforms_Intrinsic_AVX2.c
@@ -623,7 +623,7 @@ void EbHevcTransform32_AVX2_INTRIN(EB_S16 *src, EB_U32 src_stride, EB_S16 *dst,
 
     for (i = 0; i < 16; i++)
     {
-        __m256i x0, x1, x2, x3;
+        __m256i x0, x1, x2, x3,sox0,sox5,soxa,soxf,s1x0,s1x5,s1xa,s1xf;
         __m256i y0, y1, y2, y3;
         __m256i a0, a1, a2, a3, a4, a5, a6, a7;
         __m256i b0, b1, b2, b3, b4, b5, b6, b7;
@@ -652,61 +652,79 @@ void EbHevcTransform32_AVX2_INTRIN(EB_S16 *src, EB_U32 src_stride, EB_S16 *dst,
         x2 = y2;
         x3 = y3;
 
-        a0 = _mm256_madd_epi16(_mm256_shuffle_epi32(x0, 0x00), coeff32[0]);
-        a0 = _mm256_add_epi32(a0, _mm256_madd_epi16(_mm256_shuffle_epi32(x0, 0x55), coeff32[2]));
-        a0 = _mm256_add_epi32(a0, _mm256_madd_epi16(_mm256_shuffle_epi32(x0, 0xaa), coeff32[4]));
-        a0 = _mm256_add_epi32(a0, _mm256_madd_epi16(_mm256_shuffle_epi32(x0, 0xff), coeff32[6]));
-
-        a1 = _mm256_madd_epi16(_mm256_shuffle_epi32(x0, 0x00), coeff32[1]);
-        a1 = _mm256_add_epi32(a1, _mm256_madd_epi16(_mm256_shuffle_epi32(x0, 0x55), coeff32[3]));
-        a1 = _mm256_add_epi32(a1, _mm256_madd_epi16(_mm256_shuffle_epi32(x0, 0xaa), coeff32[5]));
-        a1 = _mm256_add_epi32(a1, _mm256_madd_epi16(_mm256_shuffle_epi32(x0, 0xff), coeff32[7]));
-
-        a2 = _mm256_madd_epi16(_mm256_shuffle_epi32(x1, 0x00), coeff32[8]);
-        a2 = _mm256_add_epi32(a2, _mm256_madd_epi16(_mm256_shuffle_epi32(x1, 0x55), coeff32[10]));
-        a2 = _mm256_add_epi32(a2, _mm256_madd_epi16(_mm256_shuffle_epi32(x1, 0xaa), coeff32[12]));
-        a2 = _mm256_add_epi32(a2, _mm256_madd_epi16(_mm256_shuffle_epi32(x1, 0xff), coeff32[14]));
-
-        a3 = _mm256_madd_epi16(_mm256_shuffle_epi32(x1, 0x00), coeff32[9]);
-        a3 = _mm256_add_epi32(a3, _mm256_madd_epi16(_mm256_shuffle_epi32(x1, 0x55), coeff32[11]));
-        a3 = _mm256_add_epi32(a3, _mm256_madd_epi16(_mm256_shuffle_epi32(x1, 0xaa), coeff32[13]));
-        a3 = _mm256_add_epi32(a3, _mm256_madd_epi16(_mm256_shuffle_epi32(x1, 0xff), coeff32[15]));
-
-        a4 = _mm256_madd_epi16(_mm256_shuffle_epi32(x2, 0x00), coeff32[16]);
-        a4 = _mm256_add_epi32(a4, _mm256_madd_epi16(_mm256_shuffle_epi32(x2, 0x55), coeff32[20]));
-        a4 = _mm256_add_epi32(a4, _mm256_madd_epi16(_mm256_shuffle_epi32(x2, 0xaa), coeff32[24]));
-        a4 = _mm256_add_epi32(a4, _mm256_madd_epi16(_mm256_shuffle_epi32(x2, 0xff), coeff32[28]));
-        a4 = _mm256_add_epi32(a4, _mm256_madd_epi16(_mm256_shuffle_epi32(x3, 0x00), coeff32[32]));
-        a4 = _mm256_add_epi32(a4, _mm256_madd_epi16(_mm256_shuffle_epi32(x3, 0x55), coeff32[36]));
-        a4 = _mm256_add_epi32(a4, _mm256_madd_epi16(_mm256_shuffle_epi32(x3, 0xaa), coeff32[40]));
-        a4 = _mm256_add_epi32(a4, _mm256_madd_epi16(_mm256_shuffle_epi32(x3, 0xff), coeff32[44]));
-
-        a5 = _mm256_madd_epi16(_mm256_shuffle_epi32(x2, 0x00), coeff32[17]);
-        a5 = _mm256_add_epi32(a5, _mm256_madd_epi16(_mm256_shuffle_epi32(x2, 0x55), coeff32[21]));
-        a5 = _mm256_add_epi32(a5, _mm256_madd_epi16(_mm256_shuffle_epi32(x2, 0xaa), coeff32[25]));
-        a5 = _mm256_add_epi32(a5, _mm256_madd_epi16(_mm256_shuffle_epi32(x2, 0xff), coeff32[29]));
-        a5 = _mm256_add_epi32(a5, _mm256_madd_epi16(_mm256_shuffle_epi32(x3, 0x00), coeff32[33]));
-        a5 = _mm256_add_epi32(a5, _mm256_madd_epi16(_mm256_shuffle_epi32(x3, 0x55), coeff32[37]));
-        a5 = _mm256_add_epi32(a5, _mm256_madd_epi16(_mm256_shuffle_epi32(x3, 0xaa), coeff32[41]));
-        a5 = _mm256_add_epi32(a5, _mm256_madd_epi16(_mm256_shuffle_epi32(x3, 0xff), coeff32[45]));
-
-        a6 = _mm256_madd_epi16(_mm256_shuffle_epi32(x2, 0x00), coeff32[18]);
-        a6 = _mm256_add_epi32(a6, _mm256_madd_epi16(_mm256_shuffle_epi32(x2, 0x55), coeff32[22]));
-        a6 = _mm256_add_epi32(a6, _mm256_madd_epi16(_mm256_shuffle_epi32(x2, 0xaa), coeff32[26]));
-        a6 = _mm256_add_epi32(a6, _mm256_madd_epi16(_mm256_shuffle_epi32(x2, 0xff), coeff32[30]));
-        a6 = _mm256_add_epi32(a6, _mm256_madd_epi16(_mm256_shuffle_epi32(x3, 0x00), coeff32[34]));
-        a6 = _mm256_add_epi32(a6, _mm256_madd_epi16(_mm256_shuffle_epi32(x3, 0x55), coeff32[38]));
-        a6 = _mm256_add_epi32(a6, _mm256_madd_epi16(_mm256_shuffle_epi32(x3, 0xaa), coeff32[42]));
-        a6 = _mm256_add_epi32(a6, _mm256_madd_epi16(_mm256_shuffle_epi32(x3, 0xff), coeff32[46]));
-
-        a7 = _mm256_madd_epi16(_mm256_shuffle_epi32(x2, 0x00), coeff32[19]);
-        a7 = _mm256_add_epi32(a7, _mm256_madd_epi16(_mm256_shuffle_epi32(x2, 0x55), coeff32[23]));
-        a7 = _mm256_add_epi32(a7, _mm256_madd_epi16(_mm256_shuffle_epi32(x2, 0xaa), coeff32[27]));
-        a7 = _mm256_add_epi32(a7, _mm256_madd_epi16(_mm256_shuffle_epi32(x2, 0xff), coeff32[31]));
-        a7 = _mm256_add_epi32(a7, _mm256_madd_epi16(_mm256_shuffle_epi32(x3, 0x00), coeff32[35]));
-        a7 = _mm256_add_epi32(a7, _mm256_madd_epi16(_mm256_shuffle_epi32(x3, 0x55), coeff32[39]));
-        a7 = _mm256_add_epi32(a7, _mm256_madd_epi16(_mm256_shuffle_epi32(x3, 0xaa), coeff32[43]));
-        a7 = _mm256_add_epi32(a7, _mm256_madd_epi16(_mm256_shuffle_epi32(x3, 0xff), coeff32[47]));
+		sox0 = _mm256_shuffle_epi32(x0, 0x00);
+		sox5 = _mm256_shuffle_epi32(x0, 0x55);
+		soxa = _mm256_shuffle_epi32(x0, 0xaa);
+		soxf = _mm256_shuffle_epi32(x0, 0xff);
+		s1x0 = _mm256_shuffle_epi32(x1, 0x00);
+		s1x5 = _mm256_shuffle_epi32(x1, 0x55);
+		s1xa = _mm256_shuffle_epi32(x1, 0xaa);
+		s1xf = _mm256_shuffle_epi32(x1, 0xff);	
+
+		a0 = _mm256_madd_epi16(sox0, coeff32[0]);
+        a0 = _mm256_add_epi32(a0, _mm256_madd_epi16(sox5, coeff32[2]));
+        a0 = _mm256_add_epi32(a0, _mm256_madd_epi16(soxa, coeff32[4]));
+        a0 = _mm256_add_epi32(a0, _mm256_madd_epi16(soxf, coeff32[6]));
+
+        a1 = _mm256_madd_epi16(sox0, coeff32[1]);
+        a1 = _mm256_add_epi32(a1, _mm256_madd_epi16(sox5, coeff32[3]));
+        a1 = _mm256_add_epi32(a1, _mm256_madd_epi16(soxa, coeff32[5]));
+        a1 = _mm256_add_epi32(a1, _mm256_madd_epi16(soxf, coeff32[7]));
+
+        a2 = _mm256_madd_epi16(s1x0, coeff32[8]);
+        a2 = _mm256_add_epi32(a2, _mm256_madd_epi16(s1x5, coeff32[10]));
+        a2 = _mm256_add_epi32(a2, _mm256_madd_epi16(s1xa, coeff32[12]));
+        a2 = _mm256_add_epi32(a2, _mm256_madd_epi16(s1xf, coeff32[14]));
+
+        a3 = _mm256_madd_epi16(s1x0, coeff32[9]);
+        a3 = _mm256_add_epi32(a3, _mm256_madd_epi16(s1x5, coeff32[11]));
+        a3 = _mm256_add_epi32(a3, _mm256_madd_epi16(s1xa, coeff32[13]));
+        a3 = _mm256_add_epi32(a3, _mm256_madd_epi16(s1xf, coeff32[15]));
+
+		sox0 = _mm256_shuffle_epi32(x2, 0x00);
+		sox5 = _mm256_shuffle_epi32(x2, 0x55);
+		soxa = _mm256_shuffle_epi32(x2, 0xaa);
+		soxf = _mm256_shuffle_epi32(x2, 0xff);
+		s1x0 = _mm256_shuffle_epi32(x3, 0x00);
+		s1x5 = _mm256_shuffle_epi32(x3, 0x55);
+		s1xa = _mm256_shuffle_epi32(x3, 0xaa);
+		s1xf = _mm256_shuffle_epi32(x3, 0xff);
+
+        a4 = _mm256_madd_epi16(sox0, coeff32[16]);
+        a4 = _mm256_add_epi32(a4, _mm256_madd_epi16(sox5, coeff32[20]));
+        a4 = _mm256_add_epi32(a4, _mm256_madd_epi16(soxa, coeff32[24]));
+        a4 = _mm256_add_epi32(a4, _mm256_madd_epi16(soxf, coeff32[28]));
+        a4 = _mm256_add_epi32(a4, _mm256_madd_epi16(s1x0, coeff32[32]));
+        a4 = _mm256_add_epi32(a4, _mm256_madd_epi16(s1x5, coeff32[36]));
+        a4 = _mm256_add_epi32(a4, _mm256_madd_epi16(s1xa, coeff32[40]));
+        a4 = _mm256_add_epi32(a4, _mm256_madd_epi16(s1xf, coeff32[44]));
+
+        a5 = _mm256_madd_epi16(sox0, coeff32[17]);
+        a5 = _mm256_add_epi32(a5, _mm256_madd_epi16(sox5, coeff32[21]));
+        a5 = _mm256_add_epi32(a5, _mm256_madd_epi16(soxa, coeff32[25]));
+        a5 = _mm256_add_epi32(a5, _mm256_madd_epi16(soxf, coeff32[29]));
+        a5 = _mm256_add_epi32(a5, _mm256_madd_epi16(s1x0, coeff32[33]));
+        a5 = _mm256_add_epi32(a5, _mm256_madd_epi16(s1x5, coeff32[37]));
+        a5 = _mm256_add_epi32(a5, _mm256_madd_epi16(s1xa, coeff32[41]));
+        a5 = _mm256_add_epi32(a5, _mm256_madd_epi16(s1xf, coeff32[45]));
+
+        a6 = _mm256_madd_epi16(sox0, coeff32[18]);
+        a6 = _mm256_add_epi32(a6, _mm256_madd_epi16(sox5, coeff32[22]));
+        a6 = _mm256_add_epi32(a6, _mm256_madd_epi16(soxa, coeff32[26]));
+        a6 = _mm256_add_epi32(a6, _mm256_madd_epi16(soxf, coeff32[30]));
+        a6 = _mm256_add_epi32(a6, _mm256_madd_epi16(s1x0, coeff32[34]));
+        a6 = _mm256_add_epi32(a6, _mm256_madd_epi16(s1x5, coeff32[38]));
+        a6 = _mm256_add_epi32(a6, _mm256_madd_epi16(s1xa, coeff32[42]));
+        a6 = _mm256_add_epi32(a6, _mm256_madd_epi16(s1xf, coeff32[46]));
+
+        a7 = _mm256_madd_epi16(sox0, coeff32[19]);
+        a7 = _mm256_add_epi32(a7, _mm256_madd_epi16(sox5, coeff32[23]));
+        a7 = _mm256_add_epi32(a7, _mm256_madd_epi16(soxa, coeff32[27]));
+        a7 = _mm256_add_epi32(a7, _mm256_madd_epi16(soxf, coeff32[31]));
+        a7 = _mm256_add_epi32(a7, _mm256_madd_epi16(s1x0, coeff32[35]));
+        a7 = _mm256_add_epi32(a7, _mm256_madd_epi16(s1x5, coeff32[39]));
+        a7 = _mm256_add_epi32(a7, _mm256_madd_epi16(s1xa, coeff32[43]));
+        a7 = _mm256_add_epi32(a7, _mm256_madd_epi16(s1xf, coeff32[47]));
 
         b0 = _mm256_sra_epi32(_mm256_add_epi32(a0, o0), s0);
         b1 = _mm256_sra_epi32(_mm256_add_epi32(a1, o0), s0);
@@ -1468,9 +1486,9 @@ EB_EXTERN void lowPrecisionTransform16x16_AVX2_INTRIN(EB_S16 *src, EB_U32 src_st
 // forward 32x32 transform
 EB_EXTERN void lowPrecisionTransform32x32_AVX2_INTRIN(EB_S16 *src, EB_U32 src_stride, EB_S16 *dst, EB_U32 dst_stride, EB_S16 *intermediate, EB_U32 addshift)
 {
-    EbHevcTransform32_AVX2_INTRIN(src, src_stride, intermediate, 32, 6 + addshift);
+    EbHevcTransform32_INTRIN(src, src_stride, intermediate, 32, 6 + addshift);
     EbHevcTranspose32_AVX2_INTRIN(intermediate, 32, dst, dst_stride);
-    EbHevcTransform32_AVX2_INTRIN(dst, dst_stride, intermediate, 32, 9);
+    EbHevcTransform32_INTRIN(dst, dst_stride, intermediate, 32, 9);
     EbHevcTranspose32_AVX2_INTRIN(intermediate, 32, dst, dst_stride);
 }
 
@@ -1757,3 +1775,160 @@ void MatMultNxN_AVX2_INTRIN(
     *nonzerocoeff = _mm_cvtsi128_si32(_mm_add_epi32(_mm256_extracti128_si256(z, 0), _mm256_extracti128_si256(z, 1)));
 
 }
+//VNNI code
+#ifdef VNNI_SUPPORT
+void EbHevcTransform32_VNNI_INTRIN(EB_S16 *src, EB_U32 src_stride, EB_S16 *dst, EB_U32 dst_stride, EB_U32 shift)
+{
+    EB_U32 i;
+    __m128i s0;
+    __m256i o0;
+    const __m256i *coeff32 = (const __m256i *)EbHevcCoeff_tbl_AVX2;
+    shift &= 0x0000FFFF; // Redundant code to fix Visual Studio 2012 AVX2 compiler error
+    s0 = _mm_cvtsi32_si128(shift);
+    o0 = _mm256_set1_epi32(1 << (shift - 1));
+
+    for (i = 0; i < 16; i++)
+    {
+        __m256i x0, x1, x2, x3,sox0,sox5,soxa,soxf,s1x0,s1x5,s1xa,s1xf;
+        __m256i y0, y1, y2, y3;
+        __m256i aa4, aa5, aa6, aa7;
+        __m256i a0, a1, a2, a3, a4, a5, a6, a7;
+        __m256i b0, b1, b2, b3, b4, b5, b6, b7;
+
+        x0 = _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_loadu_si128((const __m128i *)(src + 0x00))), _mm_loadu_si128((const __m128i *)(src + src_stride + 0x00)), 0x1);
+        x1 = _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_loadu_si128((const __m128i *)(src + 0x08))), _mm_loadu_si128((const __m128i *)(src + src_stride + 0x08)), 0x1);
+        x2 = _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_loadu_si128((const __m128i *)(src + 0x10))), _mm_loadu_si128((const __m128i *)(src + src_stride + 0x10)), 0x1);
+        x3 = _mm256_insertf128_si256(_mm256_castsi128_si256(_mm_loadu_si128((const __m128i *)(src + 0x18))), _mm_loadu_si128((const __m128i *)(src + src_stride + 0x18)), 0x1);
+
+        // 32-point butterfly
+        x2 = _mm256_shuffle_epi8(x2, _mm256_setr_epi8(14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1, 14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1));
+        x3 = _mm256_shuffle_epi8(x3, _mm256_setr_epi8(14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1, 14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1));
+
+        y0 = _mm256_add_epi16(x0, x3);
+        y1 = _mm256_add_epi16(x1, x2);
+
+        y2 = _mm256_sub_epi16(x0, x3);
+        y3 = _mm256_sub_epi16(x1, x2);
+
+        // 16-point butterfly
+        y1 = _mm256_shuffle_epi8(y1, _mm256_setr_epi8(14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1, 14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1));
+
+        x0 = _mm256_add_epi16(y0, y1);
+        x1 = _mm256_sub_epi16(y0, y1);
+
+        x2 = y2;
+        x3 = y3;
+
+
+		sox0 = _mm256_shuffle_epi32(x0, 0x00);
+		sox5 = _mm256_shuffle_epi32(x0, 0x55);
+		soxa = _mm256_shuffle_epi32(x0, 0xaa);
+		soxf = _mm256_shuffle_epi32(x0, 0xff);
+		s1x0 = _mm256_shuffle_epi32(x1, 0x00);
+		s1x5 = _mm256_shuffle_epi32(x1, 0x55);
+		s1xa = _mm256_shuffle_epi32(x1, 0xaa);
+		s1xf = _mm256_shuffle_epi32(x1, 0xff);	
+
+		a0 = _mm256_madd_epi16(sox0, coeff32[0]);
+
+		a0 = _mm256_dpwssd_epi32(a0, sox5, coeff32[2]);
+        a0 = _mm256_dpwssd_epi32(a0, soxa, coeff32[4]);
+        a0 = _mm256_dpwssd_epi32(a0, soxf, coeff32[6]);
+		
+        a1 = _mm256_madd_epi16(sox0, coeff32[1]);
+        a1 = _mm256_dpwssd_epi32(a1, sox5, coeff32[3]);
+        a1 = _mm256_dpwssd_epi32(a1, soxa, coeff32[5]);
+        a1 = _mm256_dpwssd_epi32(a1, soxf, coeff32[7]);
+
+        a2 = _mm256_madd_epi16(s1x0, coeff32[8]);
+        a2 = _mm256_dpwssd_epi32(a2, s1x5, coeff32[10]);
+        a2 = _mm256_dpwssd_epi32(a2, s1xa, coeff32[12]);
+        a2 = _mm256_dpwssd_epi32(a2, s1xf, coeff32[14]);
+
+        a3 = _mm256_madd_epi16(s1x0, coeff32[9]);
+        a3 = _mm256_dpwssd_epi32(a3, s1x5, coeff32[11]);
+        a3 = _mm256_dpwssd_epi32(a3, s1xa, coeff32[13]);
+        a3 = _mm256_dpwssd_epi32(a3, s1xf, coeff32[15]);		
+
+		sox0 = _mm256_shuffle_epi32(x2, 0x00);
+		sox5 = _mm256_shuffle_epi32(x2, 0x55);
+		soxa = _mm256_shuffle_epi32(x2, 0xaa);
+		soxf = _mm256_shuffle_epi32(x2, 0xff);
+		s1x0 = _mm256_shuffle_epi32(x3, 0x00);
+		s1x5 = _mm256_shuffle_epi32(x3, 0x55);
+		s1xa = _mm256_shuffle_epi32(x3, 0xaa);
+		s1xf = _mm256_shuffle_epi32(x3, 0xff);
+ 
+        a4 = _mm256_madd_epi16(sox0, coeff32[16]);
+        a4 = _mm256_dpwssd_epi32(a4, sox5, coeff32[20]);
+        a4 = _mm256_dpwssd_epi32(a4, soxa, coeff32[24]);
+        a4 = _mm256_dpwssd_epi32(a4, soxf, coeff32[28]);
+        a4 = _mm256_dpwssd_epi32(a4, s1x0, coeff32[32]);
+        a4 = _mm256_dpwssd_epi32(a4, s1x5, coeff32[36]);
+        a4 = _mm256_dpwssd_epi32(a4, s1xa, coeff32[40]);
+        a4 = _mm256_dpwssd_epi32(a4, s1xf, coeff32[44]);
+
+        a5 = _mm256_madd_epi16(sox0, coeff32[17]);
+        a5 = _mm256_dpwssd_epi32(a5, sox5, coeff32[21]);
+        a5 = _mm256_dpwssd_epi32(a5, soxa, coeff32[25]);
+        a5 = _mm256_dpwssd_epi32(a5, soxf, coeff32[29]);
+        a5 = _mm256_dpwssd_epi32(a5, s1x0, coeff32[33]);
+        a5 = _mm256_dpwssd_epi32(a5, s1x5, coeff32[37]);
+        a5 = _mm256_dpwssd_epi32(a5, s1xa, coeff32[41]);
+        a5 = _mm256_dpwssd_epi32(a5, s1xf, coeff32[45]);
+
+        a6 = _mm256_madd_epi16(sox0, coeff32[18]);
+        a6 = _mm256_dpwssd_epi32(a6, sox5, coeff32[22]);
+        a6 = _mm256_dpwssd_epi32(a6, soxa, coeff32[26]);
+        a6 = _mm256_dpwssd_epi32(a6, soxf, coeff32[30]);
+        a6 = _mm256_dpwssd_epi32(a6, s1x0, coeff32[34]);
+        a6 = _mm256_dpwssd_epi32(a6, s1x5, coeff32[38]);
+        a6 = _mm256_dpwssd_epi32(a6, s1xa, coeff32[42]);
+        a6 = _mm256_dpwssd_epi32(a6, s1xf, coeff32[46]);
+
+        a7 = _mm256_madd_epi16(sox0, coeff32[19]);
+        a7 = _mm256_dpwssd_epi32(a7, sox5, coeff32[23]);
+        a7 = _mm256_dpwssd_epi32(a7, soxa, coeff32[27]);
+        a7 = _mm256_dpwssd_epi32(a7, soxf, coeff32[31]);
+        a7 = _mm256_dpwssd_epi32(a7, s1x0, coeff32[35]);
+        a7 = _mm256_dpwssd_epi32(a7, s1x5, coeff32[39]);
+        a7 = _mm256_dpwssd_epi32(a7, s1xa, coeff32[43]);
+        a7 = _mm256_dpwssd_epi32(a7, s1xf, coeff32[47]);
+
+        b0 = _mm256_sra_epi32(_mm256_add_epi32(a0, o0), s0);
+        b1 = _mm256_sra_epi32(_mm256_add_epi32(a1, o0), s0);
+        b2 = _mm256_sra_epi32(_mm256_add_epi32(a2, o0), s0);
+        b3 = _mm256_sra_epi32(_mm256_add_epi32(a3, o0), s0);
+        b4 = _mm256_sra_epi32(_mm256_add_epi32(a4, o0), s0);
+        b5 = _mm256_sra_epi32(_mm256_add_epi32(a5, o0), s0);
+        b6 = _mm256_sra_epi32(_mm256_add_epi32(a6, o0), s0);
+        b7 = _mm256_sra_epi32(_mm256_add_epi32(a7, o0), s0);
+
+        x0 = _mm256_packs_epi32(b0, b1);
+        x1 = _mm256_packs_epi32(b2, b3);
+        x2 = _mm256_packs_epi32(b4, b5);
+        x3 = _mm256_packs_epi32(b6, b7);
+
+        y0 = _mm256_unpacklo_epi16(x0, x1);
+        y1 = _mm256_unpackhi_epi16(x0, x1);
+        y2 = x2;
+        y3 = x3;
+        x0 = _mm256_unpacklo_epi16(y0, y2);
+        x1 = _mm256_unpackhi_epi16(y0, y2);
+        x2 = _mm256_unpacklo_epi16(y1, y3);
+        x3 = _mm256_unpackhi_epi16(y1, y3);
+
+        y0 = _mm256_insertf128_si256(_mm256_castsi128_si256(_mm256_extracti128_si256(x0, 0)), _mm256_extracti128_si256(x1, 0), 0x1);
+        y1 = _mm256_insertf128_si256(_mm256_castsi128_si256(_mm256_extracti128_si256(x2, 0)), _mm256_extracti128_si256(x3, 0), 0x1);
+        y2 = _mm256_insertf128_si256(_mm256_castsi128_si256(_mm256_extracti128_si256(x0, 1)), _mm256_extracti128_si256(x1, 1), 0x1);
+        y3 = _mm256_insertf128_si256(_mm256_castsi128_si256(_mm256_extracti128_si256(x2, 1)), _mm256_extracti128_si256(x3, 1), 0x1);
+        _mm256_storeu_si256((__m256i *)(dst + 0x00), y0);
+        _mm256_storeu_si256((__m256i *)(dst + 0x10), y1);
+        _mm256_storeu_si256((__m256i *)(dst + dst_stride + 0x00), y2);
+        _mm256_storeu_si256((__m256i *)(dst + dst_stride + 0x10), y3);
+
+        src += 2 * src_stride;
+        dst += 2 * dst_stride;
+    }
+}
+#endif
diff --git a/Source/Lib/ASM_SSSE3/CMakeLists.txt b/Source/Lib/ASM_SSSE3/CMakeLists.txt
index 74147970a..7ce731694 100644
--- a/Source/Lib/ASM_SSSE3/CMakeLists.txt
+++ b/Source/Lib/ASM_SSSE3/CMakeLists.txt
@@ -16,6 +16,9 @@ include_directories(${PROJECT_SOURCE_DIR}/Source/API/
 
 set(flags_to_test
     -mssse3
+    -mavx512bw
+    -mavx512vnni
+    -mavx512vl
     -msse4.1
     -static-intel)
 
@@ -40,9 +43,9 @@ foreach(cflag ${flags_to_test})
 endforeach()
 
 if(CMAKE_C_COMPILER_ID STREQUAL "Intel")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w ")
     if(COMPILE_AS_CPP)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w ")
     endif()
 endif()
 
@@ -52,6 +55,7 @@ set(ASM_SSSE3_SOURCE
     EbDeblockingFilter_Intrinsic_SSSE3.c
     EbIntraPrediction16bit_Intrinsic_SSSE3.c
     EbMcp_Intrinsic_SSSE3.c
+    EbMcp_Intrinsic_AVX512VNNI.c
     EbSaoApplication_Intrinsic_SSSE3.c
     EbTransforms_Intrinsic_SSSE3.c)
 
diff --git a/Source/Lib/ASM_SSSE3/EbMcp_Intrinsic_AVX512VNNI.c b/Source/Lib/ASM_SSSE3/EbMcp_Intrinsic_AVX512VNNI.c
new file mode 100644
index 000000000..29bded488
--- /dev/null
+++ b/Source/Lib/ASM_SSSE3/EbMcp_Intrinsic_AVX512VNNI.c
@@ -0,0 +1,138 @@
+#include "EbMcp_SSSE3.h"
+#include "EbDefinitions.h"
+
+#include "immintrin.h"
+
+#ifdef VNNI_SUPPORT
+
+const EB_S16 EbHevcLumaFilterCoeff1[4][8] =
+{
+  { 0, 0,  0, 64,  0,  0, 0,  0},
+  {-1, 4,-10, 58, 17, -5, 1,  0},
+  {-1, 4,-11, 40, 40,-11, 4, -1},
+  { 0, 1, -5, 17, 58,-10, 4, -1}
+};
+
+static const EB_S16 EbHevcLumaFilterCoeff7[4][8] =
+  {
+    { 0, 0,  0, 64,  0,  0, 0,  0},
+    {-1, 4,-10, 58, 17, -5, 1,  0},
+    {-1, 4,-11, 40, 40,-11, 4, -1},
+    { 1, -5, 17, 58,-10, 4, -1, 0}
+  };
+
+#ifndef NON_AVX512_SUPPORT
+void LumaInterpolationFilterOneDOutRawHorizontal_AVX512(
+	EB_BYTE               refPic,
+	EB_U32                srcStride,
+	EB_S16               *dst,
+	EB_U32                puWidth,
+	EB_U32                puHeight,
+	EB_U32                fracPosx)
+{
+	EB_S32 rowCount, colCount;
+	__m128i c0, c1, c2, c3; // coeffs
+	__m128i a0, a1;
+	__m128i b0;
+	__m128i sum;
+	EB_BYTE ptr;
+
+  refPic -= 3;
+
+  PrefetchBlock(refPic, srcStride, (puWidth == 4) ? 16 : puWidth+8, (puWidth == 4) ? ((puHeight+1)&~1) : puHeight);
+
+  c0 = _mm_loadu_si128((__m128i *)EbHevcLumaFilterCoeff1[fracPosx]);
+  c0 = _mm_packs_epi16(c0, c0);
+  __m128i ct = _mm_srli_epi64(c0, 32);
+  __m512i cc0 = _mm512_broadcastd_epi32(c0);
+  __m512i cc1 = _mm512_broadcastd_epi32(ct);  
+  c0 = _mm_unpacklo_epi16(c0, c0);
+  c3 = _mm_shuffle_epi32(c0, 0xff);
+  c2 = _mm_shuffle_epi32(c0, 0xaa);
+  c1 = _mm_shuffle_epi32(c0, 0x55);
+  c0 = _mm_shuffle_epi32(c0, 0x00);
+  __m512i b1 = _mm512_set_epi8(10, 9, 8, 7, 9, 8, 7, 6, 8, 7, 6, 5, 7, 6, 5, 4, 6, 5, 4, 3, 5, 4, 3, 2, 4, 3, 2, 1, 3, 2, 1, 0, 10, 9, 8, 7, 9, 8, 7, 6, 8, 7, 6, 5, 7, 6, 5, 4, 6, 5, 4, 3, 5, 4, 3, 2, 4, 3, 2, 1, 3, 2, 1, 0);
+  __m512i b2 = _mm512_set_epi8(14, 13, 12, 11, 13, 12, 11, 10, 12, 11, 10, 9, 11, 10, 9, 8, 10, 9, 8, 7, 9, 8, 7, 6, 8, 7, 6, 5, 7, 6, 5, 4, 14, 13, 12, 11, 13, 12, 11, 10, 12, 11, 10, 9, 11, 10, 9, 8, 10, 9, 8, 7, 9, 8, 7, 6, 8, 7, 6, 5, 7, 6, 5, 4);
+  
+
+  if (puWidth & 4)
+  {
+    ptr = refPic;
+    rowCount = puHeight;
+    do
+    {
+      a0 = _mm_loadu_si128((__m128i *)ptr); ptr += srcStride;
+      a1 = _mm_loadu_si128((__m128i *)ptr); ptr += srcStride;
+      b0 = _mm_unpacklo_epi64(a0, a1);
+      sum = _mm_maddubs_epi16(_mm_shuffle_epi8(b0, _mm_setr_epi8(0, 1, 1, 2, 2, 3, 3, 4, 8, 9, 9, 10, 10, 11, 11, 12)), c0);
+      sum = _mm_add_epi16(sum, _mm_maddubs_epi16(_mm_shuffle_epi8(b0, _mm_setr_epi8(2, 3, 3, 4, 4, 5, 5, 6, 10, 11, 11, 12, 12, 13, 13, 14)), c1));
+      b0 = _mm_unpacklo_epi64(_mm_srli_si128(a0, 4), _mm_srli_si128(a1, 4));
+      sum = _mm_add_epi16(sum, _mm_maddubs_epi16(_mm_shuffle_epi8(b0, _mm_setr_epi8(0, 1, 1, 2, 2, 3, 3, 4, 8, 9, 9, 10, 10, 11, 11, 12)), c2));
+      sum = _mm_add_epi16(sum, _mm_maddubs_epi16(_mm_shuffle_epi8(b0, _mm_setr_epi8(2, 3, 3, 4, 4, 5, 5, 6, 10, 11, 11, 12, 12, 13, 13, 14)), c3));
+
+      sum = _mm_sub_epi16(sum, _mm_set1_epi16(128*64));
+
+      _mm_storeu_si128((__m128i *)dst, sum);
+      dst += 8;
+
+      rowCount -= 2;
+    }
+    while (rowCount > 0);
+
+    puWidth -= 4;
+    if (puWidth == 0)
+    {
+      return;
+    }
+
+    refPic += 4;
+  }
+  colCount = puWidth;
+  int rowLoop = puHeight >>1 ;//divide by 2 
+  int evenRow = puHeight & 1;
+  do
+  {
+    ptr = refPic;
+   // rowCount = puHeight;
+   int rowCount = rowLoop ;//divide by 2 
+   do
+    {
+		__m512i a1 = _mm512_broadcast_i32x4(_mm_loadu_si128((__m128i*)(ptr)));
+		__m256i b0 = _mm256_broadcast_i32x4(_mm_loadu_si128((__m128i*)(ptr + srcStride))); ptr += 2 * srcStride;
+		__m512i	s1 = _mm512_inserti64x4(a1, b0, 1);
+		__m512i	sh2 = _mm512_shuffle_epi8(s1, b1);
+		__m512i sh3 = _mm512_shuffle_epi8(s1, b2);
+		__m512i sum00 = _mm512_setzero_si512();
+		__m512i sum0 = _mm512_dpbusds_epi32(sum00, sh2, cc0);
+		__m512i sum1 = _mm512_dpbusds_epi32(sum0, sh3, cc1);
+		__m512i f1 = _mm512_packs_epi32(sum1,sum1);//
+		__m512i f2 = _mm512_permutexvar_epi64( _mm512_setr_epi64(0x0, 0x0000000000000002, 0x0000000000000004, 0x0000000000000006, 0x0, 0x0002000200020002, 0x0004000400040004, 0x0006000600060006), f1);
+		f2 = _mm512_sub_epi16(f2, _mm512_set1_epi16(128 * 64));
+		_mm256_storeu_si256((__m256i*)dst, _mm512_castsi512_si256(f2));
+    dst += 16;
+	  rowCount = rowCount - 1;
+    }
+    while (rowCount > 0); 
+
+    if (evenRow)
+    {
+      a0 = _mm_loadu_si128((__m128i *)ptr); ptr += srcStride;
+
+      sum = _mm_maddubs_epi16(_mm_shuffle_epi8(a0, _mm_setr_epi8(0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8)), c0);
+      sum = _mm_add_epi16(sum, _mm_maddubs_epi16(_mm_shuffle_epi8(a0, _mm_setr_epi8(2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10)), c1));
+      sum = _mm_add_epi16(sum, _mm_maddubs_epi16(_mm_shuffle_epi8(a0, _mm_setr_epi8(4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12)), c2));
+      sum = _mm_add_epi16(sum, _mm_maddubs_epi16(_mm_shuffle_epi8(a0, _mm_setr_epi8(6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14)), c3));
+
+      sum = _mm_sub_epi16(sum, _mm_set1_epi16(128*64));
+
+      _mm_storeu_si128((__m128i *)dst, sum);
+      dst += 8;
+    }
+    
+    refPic += 8;
+    colCount -= 8;
+  }
+  while (colCount > 0);
+}
+#endif
+#endif
diff --git a/Source/Lib/ASM_SSSE3/EbMcp_Intrinsic_SSSE3.c b/Source/Lib/ASM_SSSE3/EbMcp_Intrinsic_SSSE3.c
index e23e88a20..c4cd1ef23 100644
--- a/Source/Lib/ASM_SSSE3/EbMcp_Intrinsic_SSSE3.c
+++ b/Source/Lib/ASM_SSSE3/EbMcp_Intrinsic_SSSE3.c
@@ -66,7 +66,7 @@ static void _mm_storeh_epi64(__m128i * p, __m128i x)
   _mm_storeh_pd((double *)p, _mm_castsi128_pd(x));
 }
 
-static void PrefetchBlock(EB_U8 *src, EB_U32 srcStride, EB_U32 blkWidth, EB_U32 blkHeight)
+void PrefetchBlock(EB_U8 *src, EB_U32 srcStride, EB_U32 blkWidth, EB_U32 blkHeight)
 {
 #if PREFETCH
   EB_U32 rowCount = blkHeight;
@@ -232,7 +232,7 @@ void LumaInterpolationCopy_SSSE3(
 }
 
 void EbHevcLumaInterpolationFilterTwoDInRaw7_SSSE3(EB_S16 *firstPassIFDst, EB_BYTE dst, EB_U32 dstStride, EB_U32 puWidth, EB_U32 puHeight, EB_U32 fracPosy)
-{
+{   
   EB_S32 rowCount, colCount;
   __m128i c0, c1, c2;
   __m128i a0, a1, a2, a3, a4, a5, a6;
@@ -347,7 +347,8 @@ void EbHevcLumaInterpolationFilterTwoDInRaw7_SSSE3(EB_S16 *firstPassIFDst, EB_BY
     dst += 8;
     colCount -= 8;
   }
-  while (colCount > 0);
+  while (colCount > 0); 
+
 }
 
 void EbHevcLumaInterpolationFilterTwoDInRawOutRaw7_SSSE3(EB_S16 *firstPassIFDst, EB_S16 *dst, EB_U32 puWidth, EB_U32 puHeight, EB_U32 fracPosy)
@@ -453,6 +454,7 @@ void EbHevcLumaInterpolationFilterTwoDInRawOutRaw7_SSSE3(EB_S16 *firstPassIFDst,
     colCount -= 8;
   }
   while (colCount > 0);
+
 }
 
 void EbHevcLumaInterpolationFilterTwoDInRawM_SSSE3(EB_S16 *firstPassIFDst, EB_BYTE dst, EB_U32 dstStride, EB_U32 puWidth, EB_U32 puHeight)
@@ -1762,7 +1764,7 @@ void LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(
 	__m128i a0, a1;
 	__m128i b0;
 	__m128i sum;
-	EB_BYTE ptr;
+	EB_BYTE ptr;  
 
   refPic -= 3;
 
@@ -1811,7 +1813,6 @@ void LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(
 
     refPic += 4;
   }
-
   colCount = puWidth;
   do
   {
@@ -1836,7 +1837,7 @@ void LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(
     refPic += 8;
     colCount -= 8;
   }
-  while (colCount > 0);
+  while (colCount > 0); 
 }
 
 void LumaInterpolationFilterOneDOutRawHorizontalOut_SSSE3(
@@ -2313,8 +2314,8 @@ void LumaInterpolationFilterPose_SSSE3(
                                         EB_U32                puHeight,
                                         EB_S16               *firstPassIFDst)
 {
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+6, 1);
-  EbHevcLumaInterpolationFilterTwoDInRaw7_SSSE3(firstPassIFDst, dst, dstStride, puWidth, puHeight, 1);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+6, 1);
+  EbHevcLumaInterpolationFilterTwoDInRaw7(firstPassIFDst, dst, dstStride, puWidth, puHeight, 1);
 }
 
 
@@ -2329,8 +2330,8 @@ void LumaInterpolationFilterPosf_SSSE3(
 {
   EB_U32 puHeight1 = puHeight + 6;
   EB_BYTE refPic1 = refPic - 3 * srcStride;
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic1, srcStride, firstPassIFDst, puWidth, puHeight1, 2);
-  EbHevcLumaInterpolationFilterTwoDInRaw7_SSSE3(firstPassIFDst, dst, dstStride, puWidth, puHeight, 1);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic1, srcStride, firstPassIFDst, puWidth, puHeight1, 2);
+  EbHevcLumaInterpolationFilterTwoDInRaw7(firstPassIFDst, dst, dstStride, puWidth, puHeight, 1);
 }
 
 void LumaInterpolationFilterPosg_SSSE3(
@@ -2342,8 +2343,8 @@ void LumaInterpolationFilterPosg_SSSE3(
                                         EB_U32                puHeight,
                                         EB_S16               *firstPassIFDst)
 {
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+6, 3);
-  EbHevcLumaInterpolationFilterTwoDInRaw7_SSSE3(firstPassIFDst, dst, dstStride, puWidth, puHeight, 1);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+6, 3);
+  EbHevcLumaInterpolationFilterTwoDInRaw7(firstPassIFDst, dst, dstStride, puWidth, puHeight, 1);
 }
 
 void LumaInterpolationFilterPosi_SSSE3(
@@ -2355,8 +2356,8 @@ void LumaInterpolationFilterPosi_SSSE3(
                                         EB_U32                puHeight,
                                         EB_S16               *firstPassIFDst)
 {
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+7, 1);
-  EbHevcLumaInterpolationFilterTwoDInRawM_SSSE3(firstPassIFDst, dst, dstStride, puWidth, puHeight);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+7, 1);
+  EbHevcLumaInterpolationFilterTwoDInRawM(firstPassIFDst, dst, dstStride, puWidth, puHeight);
 }
 
 
@@ -2370,8 +2371,8 @@ void LumaInterpolationFilterPosj_SSSE3(
 	EB_U32                puHeight,
 	EB_S16               *firstPassIFDst)
 {
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+7, 2);
-  EbHevcLumaInterpolationFilterTwoDInRawM_SSSE3(firstPassIFDst, dst, dstStride, puWidth, puHeight);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+7, 2);
+  EbHevcLumaInterpolationFilterTwoDInRawM(firstPassIFDst, dst, dstStride, puWidth, puHeight);
 }
 
 void LumaInterpolationFilterPosk_SSSE3(
@@ -2383,8 +2384,8 @@ void LumaInterpolationFilterPosk_SSSE3(
 	EB_U32                puHeight,
 	EB_S16               *firstPassIFDst)
 {
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+7, 3);
-  EbHevcLumaInterpolationFilterTwoDInRawM_SSSE3(firstPassIFDst, dst, dstStride, puWidth, puHeight);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+7, 3);
+  EbHevcLumaInterpolationFilterTwoDInRawM(firstPassIFDst, dst, dstStride, puWidth, puHeight);
 }
 
 void LumaInterpolationFilterPosp_SSSE3(
@@ -2396,8 +2397,8 @@ void LumaInterpolationFilterPosp_SSSE3(
 	EB_U32                puHeight,
 	EB_S16               *firstPassIFDst)
 {
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic-2*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+6, 1);
-  EbHevcLumaInterpolationFilterTwoDInRaw7_SSSE3(firstPassIFDst, dst, dstStride, puWidth, puHeight, 3);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic-2*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+6, 1);
+  EbHevcLumaInterpolationFilterTwoDInRaw7(firstPassIFDst, dst, dstStride, puWidth, puHeight, 3);
 }
 
 void LumaInterpolationFilterPosq_SSSE3(
@@ -2411,8 +2412,8 @@ void LumaInterpolationFilterPosq_SSSE3(
 {
   EB_U32 puHeight1 = puHeight + 6;
   EB_BYTE refPic1 = refPic - 2 * srcStride;
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic1, srcStride, firstPassIFDst, puWidth, puHeight1, 2);
-  EbHevcLumaInterpolationFilterTwoDInRaw7_SSSE3(firstPassIFDst, dst, dstStride, puWidth, puHeight, 3);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic1, srcStride, firstPassIFDst, puWidth, puHeight1, 2);
+  EbHevcLumaInterpolationFilterTwoDInRaw7(firstPassIFDst, dst, dstStride, puWidth, puHeight, 3);
 }
 
 void LumaInterpolationFilterPosr_SSSE3(
@@ -2424,8 +2425,8 @@ void LumaInterpolationFilterPosr_SSSE3(
 	EB_U32                puHeight,
 	EB_S16               *firstPassIFDst)
 {
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic-2*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+6, 3);
-  EbHevcLumaInterpolationFilterTwoDInRaw7_SSSE3(firstPassIFDst, dst, dstStride, puWidth, puHeight, 3);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic-2*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+6, 3);
+  EbHevcLumaInterpolationFilterTwoDInRaw7(firstPassIFDst, dst, dstStride, puWidth, puHeight, 3);
 }
 
 
@@ -2452,7 +2453,7 @@ void LumaInterpolationFilterPosaOutRaw_SSSE3(
 	EB_S16               *firstPassIFDst)
 {
   (void)firstPassIFDst;
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic, srcStride, dst, puWidth, puHeight, 1);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic, srcStride, dst, puWidth, puHeight, 1);
 }
 
 void LumaInterpolationFilterPosbOutRaw_SSSE3(
@@ -2465,7 +2466,7 @@ void LumaInterpolationFilterPosbOutRaw_SSSE3(
 {
   (void)firstPassIFDst;
   //LumaInterpolationFilterOneDOutRawHorizontalOut_SSSE3(refPic, srcStride, dst, puWidth, puHeight, 2);
- LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic, srcStride, dst, puWidth, puHeight, 2);
+ LumaInterpolationFilterOneDOutRawHorizontal(refPic, srcStride, dst, puWidth, puHeight, 2);
 }
 
 void LumaInterpolationFilterPoscOutRaw_SSSE3(
@@ -2478,7 +2479,7 @@ void LumaInterpolationFilterPoscOutRaw_SSSE3(
 {
   (void)firstPassIFDst;
   //LumaInterpolationFilterOneDOutRawHorizontalOut_SSSE3(refPic, srcStride, dst, puWidth, puHeight, 3);
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic, srcStride, dst, puWidth, puHeight, 3);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic, srcStride, dst, puWidth, puHeight, 3);
 }
 
 void LumaInterpolationFilterPosdOutRaw_SSSE3(
@@ -2798,7 +2799,447 @@ void BiPredClippingOnTheFly_SSSE3(
 		dst += 8;
 	} while (colCount != 0);
 }
+//Vnni code
+#ifdef VNNI_SUPPORT
+void EbHevcLumaInterpolationFilterTwoDInRawOutRaw7_VNNI(EB_S16 *firstPassIFDst, EB_S16 *dst, EB_U32 puWidth, EB_U32 puHeight, EB_U32 fracPosy)
+{
+  EB_S32 rowCount, colCount;
+  __m128i a0, a1, a2, a3, a4, a5, a6;
+  __m128i c0, c1, c2;
+  c0 = _mm_loadu_si128((__m128i *)EbHevcLumaFilterCoeff7[fracPosy]);
+  c2 = _mm_shuffle_epi32(c0, 0xaa);
+  c1 = _mm_shuffle_epi32(c0, 0x55);
+  c0 = _mm_shuffle_epi32(c0, 0x00);
+
+  if (puWidth & 4)
+  {
+    rowCount = puHeight;
+
+    do
+    {
+      __m128i sum0, sum1;
+      a0 = _mm_loadu_si128((__m128i *)(firstPassIFDst+0*4));
+      a1 = _mm_loadu_si128((__m128i *)(firstPassIFDst+1*4));
+      a2 = _mm_loadu_si128((__m128i *)(firstPassIFDst+2*4));
+      a3 = _mm_loadu_si128((__m128i *)(firstPassIFDst+3*4));
+      a4 = _mm_loadu_si128((__m128i *)(firstPassIFDst+4*4));
+      a5 = _mm_loadu_si128((__m128i *)(firstPassIFDst+5*4));
+      a6 = _mm_loadu_si128((__m128i *)(firstPassIFDst+6*4));
+      a0 = _mm_sub_epi16(a0, a6);
+
+      sum0 = _mm_madd_epi16(_mm_unpacklo_epi16(a0, a1), c0);
+      sum1 = _mm_madd_epi16(_mm_unpackhi_epi16(a0, a1), c0);
+
+      sum0 = _mm_dpwssd_epi32(sum0, _mm_unpacklo_epi16(a2, a3), c1);
+      sum1 = _mm_dpwssd_epi32(sum1, _mm_unpackhi_epi16(a2, a3), c1);
+      sum0 = _mm_dpwssd_epi32(sum0, _mm_unpacklo_epi16(a4, a5), c2);
+      sum1 = _mm_dpwssd_epi32(sum1, _mm_unpackhi_epi16(a4, a5), c2);
+
+      sum0 = _mm_srai_epi32(sum0, 6);
+      sum1 = _mm_srai_epi32(sum1, 6);
+      sum0 = _mm_packs_epi32(sum0, sum1);
+
+      _mm_storeu_si128((__m128i *)dst, sum0);
+      dst += 8;
+
+      firstPassIFDst += 8;
+      rowCount -= 2;
+    }
+    while (rowCount > 0);
+
+    puWidth -= 4;
+    if (puWidth == 0)
+    {
+      return;
+    }
+
+    firstPassIFDst += (fracPosy == 2) ? 32 : 24;
+  }
+
+  colCount = puWidth;
+  do
+  {
+    rowCount = puHeight;
+    do
+    {
+      __m128i b0l, b0h, b1l, b1h, b2l, b2h;
+      __m128i sum0, sum1;
+
+      a0 = _mm_loadu_si128((__m128i *)(firstPassIFDst+0*8));
+      a1 = _mm_loadu_si128((__m128i *)(firstPassIFDst+1*8));
+      a2 = _mm_loadu_si128((__m128i *)(firstPassIFDst+2*8));
+      a3 = _mm_loadu_si128((__m128i *)(firstPassIFDst+3*8));
+      a4 = _mm_loadu_si128((__m128i *)(firstPassIFDst+4*8));
+      a5 = _mm_loadu_si128((__m128i *)(firstPassIFDst+5*8));
+      a6 = _mm_loadu_si128((__m128i *)(firstPassIFDst+6*8));
+      a0 = _mm_sub_epi16(a0, a6);
+
+      b0l = _mm_unpacklo_epi16(a0, a1);
+      b0h = _mm_unpackhi_epi16(a0, a1);
+      b1l = _mm_unpacklo_epi16(a2, a3);
+      b1h = _mm_unpackhi_epi16(a2, a3);
+      b2l = _mm_unpacklo_epi16(a4, a5);
+      b2h = _mm_unpackhi_epi16(a4, a5);
+
+      sum0 = _mm_madd_epi16(b0l, c0);
+      sum1 = _mm_madd_epi16(b0h, c0);
+
+      sum0 = _mm_dpwssd_epi32(sum0, b1l, c1);
+      sum1 = _mm_dpwssd_epi32(sum1, b1h, c1);
+      sum0 = _mm_dpwssd_epi32(sum0, b2l, c2);
+      sum1 = _mm_dpwssd_epi32(sum1, b2h, c2);
+      
+      sum0 = _mm_srai_epi32(sum0, 6);
+      sum1 = _mm_srai_epi32(sum1, 6);
+      sum0 = _mm_packs_epi32(sum0, sum1);
+
+      _mm_storeu_si128((__m128i *)dst, sum0);
+      dst += 8;
+
+      firstPassIFDst += 8;
+      rowCount--;
+    }
+    while (rowCount > 0);
+
+    firstPassIFDst += (fracPosy == 2) ? 56 : 48;
+    colCount -= 8;
+  }
+  while (colCount > 0);
+
+}
+
+void EbHevcLumaInterpolationFilterTwoDInRawM_VNNI(EB_S16 *firstPassIFDst, EB_BYTE dst, EB_U32 dstStride, EB_U32 puWidth, EB_U32 puHeight)
+{
+  EB_S32 rowCount, colCount;
+
+  __m128i c0, c1;
+  __m128i a0, a1, a2, a3, a4, a5, a6, a7;
+  __m128i sum0, sum1;
+
+  EB_BYTE qtr;
+
+  c0 = _mm_loadu_si128((__m128i *)EbHevcLumaFilterCoeff7[2]);
+  c1 = _mm_shuffle_epi32(c0, 0x55);
+  c0 = _mm_shuffle_epi32(c0, 0x00);
+
+
+
+  if (puWidth & 4)
+  {
+    rowCount = puHeight;
+    qtr = dst;
+
+    do
+    {
+      a0 = _mm_loadu_si128((__m128i *)(firstPassIFDst+0*4));
+      a1 = _mm_loadu_si128((__m128i *)(firstPassIFDst+1*4));
+      a2 = _mm_loadu_si128((__m128i *)(firstPassIFDst+2*4));
+      a3 = _mm_loadu_si128((__m128i *)(firstPassIFDst+3*4));
+      a4 = _mm_loadu_si128((__m128i *)(firstPassIFDst+4*4));
+      a5 = _mm_loadu_si128((__m128i *)(firstPassIFDst+5*4));
+      a6 = _mm_loadu_si128((__m128i *)(firstPassIFDst+6*4));
+      a7 = _mm_loadu_si128((__m128i *)(firstPassIFDst+7*4));
+
+      sum0 = _mm_set1_epi32(257<<11);
+      sum1 = _mm_set1_epi32(257<<11);
+
+      a0 = _mm_add_epi16(a0, a7);
+      a1 = _mm_add_epi16(a1, a6);
+      a2 = _mm_add_epi16(a2, a5);
+      a3 = _mm_add_epi16(a3, a4);
+      sum0 = _mm_dpwssd_epi32(sum0, _mm_unpacklo_epi16(a0, a1), c0);
+      sum1 = _mm_dpwssd_epi32(sum1, _mm_unpackhi_epi16(a0, a1), c0);
+      sum0 = _mm_dpwssd_epi32(sum0, _mm_unpacklo_epi16(a2, a3), c1);
+      sum1 = _mm_dpwssd_epi32(sum1, _mm_unpackhi_epi16(a2, a3), c1);
+
+      sum0 = _mm_srai_epi32(sum0, 12);
+      sum1 = _mm_srai_epi32(sum1, 12);
+      sum0 = _mm_packs_epi32(sum0, sum1);
+      sum0 = _mm_packus_epi16(sum0, sum0);
+
+      *(EB_U32 *)qtr = _mm_extract_epi32(sum0, 0); qtr += dstStride;
+      *(EB_U32 *)qtr = _mm_extract_epi32(sum0, 1); qtr += dstStride;
+      firstPassIFDst += 8;
+      rowCount -= 2;
+    }
+    while (rowCount > 0);
+
+    puWidth -= 4;
+    if (puWidth == 0)
+    {
+      return;
+    }
+
+    firstPassIFDst += 32;
+    dst += 4;
+  }
+
+  colCount = puWidth;
+  do
+  {
+    qtr = dst;
+
+    rowCount = puHeight;
+    do
+    {
+      a0 = _mm_loadu_si128((__m128i *)(firstPassIFDst+0*8));
+      a1 = _mm_loadu_si128((__m128i *)(firstPassIFDst+1*8));
+      a2 = _mm_loadu_si128((__m128i *)(firstPassIFDst+2*8));
+      a3 = _mm_loadu_si128((__m128i *)(firstPassIFDst+3*8));
+      a4 = _mm_loadu_si128((__m128i *)(firstPassIFDst+4*8));
+      a5 = _mm_loadu_si128((__m128i *)(firstPassIFDst+5*8));
+      a6 = _mm_loadu_si128((__m128i *)(firstPassIFDst+6*8));
+      a7 = _mm_loadu_si128((__m128i *)(firstPassIFDst+7*8));
+
+      sum0 = _mm_set1_epi32(257<<11);
+      sum1 = _mm_set1_epi32(257<<11);
+      a0 = _mm_add_epi16(a0, a7);
+      a1 = _mm_add_epi16(a1, a6);
+      a2 = _mm_add_epi16(a2, a5);
+      a3 = _mm_add_epi16(a3, a4);
+      sum0 = _mm_dpwssd_epi32(sum0, _mm_unpacklo_epi16(a0, a1), c0);
+      sum1 = _mm_dpwssd_epi32(sum1, _mm_unpackhi_epi16(a0, a1), c0);
+      sum0 = _mm_dpwssd_epi32(sum0, _mm_unpacklo_epi16(a2, a3), c1);
+      sum1 = _mm_dpwssd_epi32(sum1, _mm_unpackhi_epi16(a2, a3), c1);
+
+      sum0 = _mm_srai_epi32(sum0, 12);
+      sum1 = _mm_srai_epi32(sum1, 12);
+      sum0 = _mm_packs_epi32(sum0, sum1);
+      sum0 = _mm_packus_epi16(sum0, sum0);
+
+      _mm_storel_epi64((__m128i *)qtr, sum0); qtr += dstStride;
+      firstPassIFDst += 8;
+    }
+    while (--rowCount > 0);
+
+    firstPassIFDst += 56;
+    dst += 8;
+    colCount -= 8;
+  }
+  while (colCount > 0);
+}
+
+void EbHevcLumaInterpolationFilterTwoDInRawOutRawM_VNNI(EB_S16 *firstPassIFDst, EB_S16 *dst, EB_U32 puWidth, EB_U32 puHeight)
+{
+  EB_S32 rowCount, colCount;
+
+  __m128i a0, a1, a2, a3, a4, a5, a6, a7;
+  __m128i c0, c1;
+  c0 = _mm_loadu_si128((__m128i *)EbHevcLumaFilterCoeff7[2]);
+  c1 = _mm_shuffle_epi32(c0, 0x55);
+  c0 = _mm_shuffle_epi32(c0, 0x00);
+
+  if (puWidth & 4)
+  {
+    rowCount = puHeight;
+
+    do
+    {
+      __m128i sum0, sum1;
+      a0 = _mm_loadu_si128((__m128i *)(firstPassIFDst+0*4));
+      a1 = _mm_loadu_si128((__m128i *)(firstPassIFDst+1*4));
+      a2 = _mm_loadu_si128((__m128i *)(firstPassIFDst+2*4));
+      a3 = _mm_loadu_si128((__m128i *)(firstPassIFDst+3*4));
+      a4 = _mm_loadu_si128((__m128i *)(firstPassIFDst+4*4));
+      a5 = _mm_loadu_si128((__m128i *)(firstPassIFDst+5*4));
+      a6 = _mm_loadu_si128((__m128i *)(firstPassIFDst+6*4));
+      a7 = _mm_loadu_si128((__m128i *)(firstPassIFDst+7*4));
+
+      a0 = _mm_add_epi16(a0, a7);
+      a1 = _mm_add_epi16(a1, a6);
+      a2 = _mm_add_epi16(a2, a5);
+      a3 = _mm_add_epi16(a3, a4);
+      sum0 = _mm_madd_epi16(_mm_unpacklo_epi16(a0, a1), c0);
+      sum1 = _mm_madd_epi16(_mm_unpackhi_epi16(a0, a1), c0);
+      sum0 = _mm_dpwssd_epi32(sum0, _mm_unpacklo_epi16(a2, a3), c1);
+      sum1 = _mm_dpwssd_epi32(sum1, _mm_unpackhi_epi16(a2, a3), c1);
+
+      sum0 = _mm_srai_epi32(sum0, 6);
+      sum1 = _mm_srai_epi32(sum1, 6);
+      sum0 = _mm_packs_epi32(sum0, sum1);
+
+      _mm_storeu_si128((__m128i *)dst, sum0);
+      dst += 8;
+      firstPassIFDst += 8;
+      rowCount -= 2;
+    }
+    while (rowCount > 0);
+
+    puWidth -= 4;
+    if (puWidth == 0)
+    {
+      return;
+    }
+
+    firstPassIFDst += 32;
+  }
+
+  colCount = puWidth;
+  do
+  {
+    rowCount = puHeight;
+    do
+    {
+      __m128i sum0, sum1;
+      a0 = _mm_loadu_si128((__m128i *)(firstPassIFDst+0*8));
+      a1 = _mm_loadu_si128((__m128i *)(firstPassIFDst+1*8));
+      a2 = _mm_loadu_si128((__m128i *)(firstPassIFDst+2*8));
+      a3 = _mm_loadu_si128((__m128i *)(firstPassIFDst+3*8));
+      a4 = _mm_loadu_si128((__m128i *)(firstPassIFDst+4*8));
+      a5 = _mm_loadu_si128((__m128i *)(firstPassIFDst+5*8));
+      a6 = _mm_loadu_si128((__m128i *)(firstPassIFDst+6*8));
+      a7 = _mm_loadu_si128((__m128i *)(firstPassIFDst+7*8));
+
+      a0 = _mm_add_epi16(a0, a7);
+      a1 = _mm_add_epi16(a1, a6);
+      a2 = _mm_add_epi16(a2, a5);
+      a3 = _mm_add_epi16(a3, a4);
+      sum0 = _mm_madd_epi16(_mm_unpacklo_epi16(a0, a1), c0);
+      sum1 = _mm_madd_epi16(_mm_unpackhi_epi16(a0, a1), c0);
+      sum0 = _mm_dpwssd_epi32(sum0, _mm_unpacklo_epi16(a2, a3), c1);
+      sum1 = _mm_dpwssd_epi32(sum1, _mm_unpackhi_epi16(a2, a3), c1);
+
+      sum0 = _mm_srai_epi32(sum0, 6);
+      sum1 = _mm_srai_epi32(sum1, 6);
+      sum0 = _mm_packs_epi32(sum0, sum1);
+
+      _mm_storeu_si128((__m128i *)dst, sum0);
+      dst += 8;
+      firstPassIFDst += 8;
+    }
+    while (--rowCount > 0);
+
+    firstPassIFDst += 56;
+    colCount -= 8;
+  }
+  while (colCount > 0);
+}
+
+void EbHevcLumaInterpolationFilterTwoDInRaw7_VNNI(EB_S16 *firstPassIFDst, EB_BYTE dst, EB_U32 dstStride, EB_U32 puWidth, EB_U32 puHeight, EB_U32 fracPosy)
+{
+  EB_S32 rowCount, colCount;
+  __m128i c0, c1, c2;
+  __m128i a0, a1, a2, a3, a4, a5, a6;
+  __m128i sum0 , sum1;
+  __m128i b0l, b0h, b1l, b1h, b2l, b2h;
+  EB_BYTE qtr;
+  c0 = _mm_loadu_si128((__m128i *)EbHevcLumaFilterCoeff7[fracPosy]);
+  c2 = _mm_shuffle_epi32(c0, 0xaa);
+  c1 = _mm_shuffle_epi32(c0, 0x55);
+  c0 = _mm_shuffle_epi32(c0, 0x00);
+
+
+  if (puWidth & 4)
+  {
+    rowCount = puHeight;
+
+    qtr = dst;
+
+    do
+    {
+      a0 = _mm_loadu_si128((__m128i *)(firstPassIFDst+0*4));
+      a1 = _mm_loadu_si128((__m128i *)(firstPassIFDst+1*4));
+      a2 = _mm_loadu_si128((__m128i *)(firstPassIFDst+2*4));
+      a3 = _mm_loadu_si128((__m128i *)(firstPassIFDst+3*4));
+      a4 = _mm_loadu_si128((__m128i *)(firstPassIFDst+4*4));
+      a5 = _mm_loadu_si128((__m128i *)(firstPassIFDst+5*4));
+      a6 = _mm_loadu_si128((__m128i *)(firstPassIFDst+6*4));
+      a0 = _mm_sub_epi16(a0, a6);
+
+      sum0 = _mm_set1_epi32(257<<11);
+      sum1 = _mm_set1_epi32(257<<11);
+
+
+      b0l = _mm_unpacklo_epi16(a0, a1);
+      b0h = _mm_unpackhi_epi16(a0, a1);
+      b1l = _mm_unpacklo_epi16(a2, a3);
+      b1h = _mm_unpackhi_epi16(a2, a3);
+      b2l = _mm_unpacklo_epi16(a4, a5);
+      b2h = _mm_unpackhi_epi16(a4, a5);
+
+      sum0 = _mm_dpwssd_epi32(sum0, b0l, c0);
+      sum1 = _mm_dpwssd_epi32(sum1, b0h, c0);
+      sum0 = _mm_dpwssd_epi32(sum0, b1l, c1);
+      sum1 = _mm_dpwssd_epi32(sum1, b1h, c1);
+      sum0 = _mm_dpwssd_epi32(sum0, b2l, c2);
+      sum1 = _mm_dpwssd_epi32(sum1, b2h, c2);
+
+      sum0 = _mm_srai_epi32(sum0, 12);
+      sum1 = _mm_srai_epi32(sum1, 12);
+      sum0 = _mm_packs_epi32(sum0, sum1);
+      sum0 = _mm_packus_epi16(sum0, sum0);
+
+      *(EB_U32 *)qtr = _mm_extract_epi32(sum0, 0); qtr += dstStride;
+      *(EB_U32 *)qtr = _mm_extract_epi32(sum0, 1); qtr += dstStride;
+
+      firstPassIFDst += 8;
+      rowCount -= 2;
+    }
+    while (rowCount > 0);
+
+    puWidth -= 4;
+    if (puWidth == 0)
+    {
+      return;
+    }
 
+    firstPassIFDst += (fracPosy == 2) ? 32 : 24;
+    dst += 4;
+  }
+
+  colCount = puWidth;
+  do
+  {
+    EB_BYTE qtr = dst;
+
+    rowCount = puHeight;
+    do
+    {
+      a0 = _mm_loadu_si128((__m128i *)(firstPassIFDst+0*8));
+      a1 = _mm_loadu_si128((__m128i *)(firstPassIFDst+1*8));
+      a2 = _mm_loadu_si128((__m128i *)(firstPassIFDst+2*8));
+      a3 = _mm_loadu_si128((__m128i *)(firstPassIFDst+3*8));
+      a4 = _mm_loadu_si128((__m128i *)(firstPassIFDst+4*8));
+      a5 = _mm_loadu_si128((__m128i *)(firstPassIFDst+5*8));
+      a6 = _mm_loadu_si128((__m128i *)(firstPassIFDst+6*8));
+      a0 = _mm_sub_epi16(a0, a6);
+
+      sum0 = _mm_set1_epi32(257<<11);
+      sum1 = _mm_set1_epi32(257<<11);
+
+      b0l = _mm_unpacklo_epi16(a0, a1);
+      b0h = _mm_unpackhi_epi16(a0, a1);
+      b1l = _mm_unpacklo_epi16(a2, a3);
+      b1h = _mm_unpackhi_epi16(a2, a3);
+      b2l = _mm_unpacklo_epi16(a4, a5);
+      b2h = _mm_unpackhi_epi16(a4, a5);
+
+      sum0 = _mm_dpwssd_epi32(sum0, b0l, c0);
+      sum1 = _mm_dpwssd_epi32(sum1, b0h, c0);
+      sum0 = _mm_dpwssd_epi32(sum0, b1l, c1);
+      sum1 = _mm_dpwssd_epi32(sum1, b1h, c1);
+      sum0 = _mm_dpwssd_epi32(sum0, b2l, c2);
+      sum1 = _mm_dpwssd_epi32(sum1, b2h, c2);
+
+      sum0 = _mm_srai_epi32(sum0, 12);
+      sum1 = _mm_srai_epi32(sum1, 12);
+      sum0 = _mm_packs_epi32(sum0, sum1);
+      sum0 = _mm_packus_epi16(sum0, sum0);
+
+      _mm_storel_epi64((__m128i *)qtr, sum0); qtr += dstStride;
+
+      firstPassIFDst += 8;
+      rowCount--;
+    }
+    while (rowCount > 0);
+
+    firstPassIFDst += (fracPosy == 2) ? 56 : 48;
+    dst += 8;
+    colCount -= 8;
+  }
+  while (colCount > 0);
+}
+#endif
 
 void LumaInterpolationFilterPosnOutRaw_SSSE3(
                                               EB_BYTE               refPic,
@@ -2821,8 +3262,8 @@ void LumaInterpolationFilterPoseOutRaw_SSSE3(
                                               EB_U32                puHeight,
                                               EB_S16               *firstPassIFDst)
 {
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+6, 1);
-  EbHevcLumaInterpolationFilterTwoDInRawOutRaw7_SSSE3(firstPassIFDst, dst, puWidth, puHeight, 1);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+6, 1);
+  EbHevcLumaInterpolationFilterTwoDInRawOutRaw7(firstPassIFDst, dst, puWidth, puHeight, 1);
 }
 
 void LumaInterpolationFilterPosfOutRaw_SSSE3(
@@ -2835,8 +3276,8 @@ void LumaInterpolationFilterPosfOutRaw_SSSE3(
 {
   EB_U32 puHeight1 = puHeight + 6;
   EB_BYTE refPic1 = refPic - 3 * srcStride;
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic1, srcStride, firstPassIFDst, puWidth, puHeight1, 2);
-  EbHevcLumaInterpolationFilterTwoDInRawOutRaw7_SSSE3(firstPassIFDst, dst, puWidth, puHeight, 1);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic1, srcStride, firstPassIFDst, puWidth, puHeight1, 2);
+  EbHevcLumaInterpolationFilterTwoDInRawOutRaw7(firstPassIFDst, dst, puWidth, puHeight, 1);
 }
 
 void LumaInterpolationFilterPosgOutRaw_SSSE3(
@@ -2847,8 +3288,8 @@ void LumaInterpolationFilterPosgOutRaw_SSSE3(
                                               EB_U32                puHeight,
                                               EB_S16               *firstPassIFDst)
 {
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+6, 3);
-  EbHevcLumaInterpolationFilterTwoDInRawOutRaw7_SSSE3(firstPassIFDst, dst, puWidth, puHeight, 1);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+6, 3);
+  EbHevcLumaInterpolationFilterTwoDInRawOutRaw7(firstPassIFDst, dst, puWidth, puHeight, 1);
 }
 
 void LumaInterpolationFilterPosiOutRaw_SSSE3(
@@ -2859,7 +3300,7 @@ void LumaInterpolationFilterPosiOutRaw_SSSE3(
                                               EB_U32                puHeight,
                                               EB_S16               *firstPassIFDst)
 {
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+7, 1);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+7, 1);
   EbHevcLumaInterpolationFilterTwoDInRawOutRawM_SSSE3(firstPassIFDst, dst, puWidth, puHeight);
 }
 
@@ -2871,7 +3312,7 @@ void LumaInterpolationFilterPosjOutRaw_SSSE3(
                                               EB_U32                puHeight,
                                               EB_S16               *firstPassIFDst)
 {
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+7, 2);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+7, 2);
   EbHevcLumaInterpolationFilterTwoDInRawOutRawM_SSSE3(firstPassIFDst, dst, puWidth, puHeight);
 }
 
@@ -2883,7 +3324,7 @@ void LumaInterpolationFilterPoskOutRaw_SSSE3(
                                               EB_U32                puHeight,
                                               EB_S16               *firstPassIFDst)
 {
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+7, 3);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic-3*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+7, 3);
   EbHevcLumaInterpolationFilterTwoDInRawOutRawM_SSSE3(firstPassIFDst, dst, puWidth, puHeight);
 }
 
@@ -2895,8 +3336,8 @@ void LumaInterpolationFilterPospOutRaw_SSSE3(
                                               EB_U32                puHeight,
                                               EB_S16               *firstPassIFDst)
 {
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic-2*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+6, 1);
-  EbHevcLumaInterpolationFilterTwoDInRawOutRaw7_SSSE3(firstPassIFDst, dst, puWidth, puHeight, 3);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic-2*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+6, 1);
+  EbHevcLumaInterpolationFilterTwoDInRawOutRaw7(firstPassIFDst, dst, puWidth, puHeight, 3);
 }
 
 void LumaInterpolationFilterPosqOutRaw_SSSE3(
@@ -2909,8 +3350,8 @@ void LumaInterpolationFilterPosqOutRaw_SSSE3(
 {
   EB_U32 puHeight1 = puHeight + 6;
   EB_BYTE refPic1 = refPic - 2 * srcStride;
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic1, srcStride, firstPassIFDst, puWidth, puHeight1, 2);
-  EbHevcLumaInterpolationFilterTwoDInRawOutRaw7_SSSE3(firstPassIFDst, dst, puWidth, puHeight, 3);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic1, srcStride, firstPassIFDst, puWidth, puHeight1, 2);
+  EbHevcLumaInterpolationFilterTwoDInRawOutRaw7(firstPassIFDst, dst, puWidth, puHeight, 3);
 }
 
 void LumaInterpolationFilterPosrOutRaw_SSSE3(
@@ -2921,6 +3362,6 @@ void LumaInterpolationFilterPosrOutRaw_SSSE3(
                                               EB_U32                puHeight,
                                               EB_S16               *firstPassIFDst)
 {
-  LumaInterpolationFilterOneDOutRawHorizontal_SSSE3(refPic-2*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+6, 3);
-  EbHevcLumaInterpolationFilterTwoDInRawOutRaw7_SSSE3(firstPassIFDst, dst, puWidth, puHeight, 3);
+  LumaInterpolationFilterOneDOutRawHorizontal(refPic-2*srcStride, srcStride, firstPassIFDst, puWidth, puHeight+6, 3);
+  EbHevcLumaInterpolationFilterTwoDInRawOutRaw7(firstPassIFDst, dst, puWidth, puHeight, 3);
 }
diff --git a/Source/Lib/ASM_SSSE3/EbMcp_SSSE3.h b/Source/Lib/ASM_SSSE3/EbMcp_SSSE3.h
index ba5fce2e4..98538ede3 100644
--- a/Source/Lib/ASM_SSSE3/EbMcp_SSSE3.h
+++ b/Source/Lib/ASM_SSSE3/EbMcp_SSSE3.h
@@ -12,6 +12,18 @@
 extern "C" {
 #endif
 
+#ifdef VNNI_SUPPORT
+#define LumaInterpolationFilterOneDOutRawHorizontal LumaInterpolationFilterOneDOutRawHorizontal_SSSE3
+#define EbHevcLumaInterpolationFilterTwoDInRaw7 EbHevcLumaInterpolationFilterTwoDInRaw7_VNNI
+#define EbHevcLumaInterpolationFilterTwoDInRawOutRaw7 EbHevcLumaInterpolationFilterTwoDInRawOutRaw7_VNNI
+#define EbHevcLumaInterpolationFilterTwoDInRawM EbHevcLumaInterpolationFilterTwoDInRawM_VNNI
+#else
+#define EbHevcLumaInterpolationFilterTwoDInRaw7 EbHevcLumaInterpolationFilterTwoDInRaw7_SSSE3
+#define LumaInterpolationFilterOneDOutRawHorizontal LumaInterpolationFilterOneDOutRawHorizontal_SSSE3
+#define EbHevcLumaInterpolationFilterTwoDInRawOutRaw7 EbHevcLumaInterpolationFilterTwoDInRawOutRaw7_SSSE3
+#define EbHevcLumaInterpolationFilterTwoDInRawM EbHevcLumaInterpolationFilterTwoDInRawM_SSSE3
+#endif
+
 // SSSE3 functions
 void ChromaInterpolationCopy_SSSE3(EB_BYTE refPic, EB_U32 srcStride, EB_BYTE dst, EB_U32 dstStride, EB_U32 puWidth, EB_U32 puHeight, EB_S16 *firstPassIFDst, EB_U32 fracPosx, EB_U32 fracPosy);
 void ChromaInterpolationFilterOneDHorizontal_SSSE3(EB_BYTE refPic, EB_U32 srcStride, EB_BYTE dst, EB_U32 dstStride, EB_U32 puWidth, EB_U32 puHeight, EB_S16 *firstPassIFDst, EB_U32 fracPosx, EB_U32 fracPosy);
@@ -71,4 +83,4 @@ void BiPredClippingOnTheFly_SSSE3(
 #ifdef __cplusplus
 }
 #endif
-#endif //EBMCP_SSSE3_H
\ No newline at end of file
+#endif //EBMCP_SSSE3_H
diff --git a/Source/Lib/Codec/EbDefinitions.h b/Source/Lib/Codec/EbDefinitions.h
index adf38d530..7c921c83c 100644
--- a/Source/Lib/Codec/EbDefinitions.h
+++ b/Source/Lib/Codec/EbDefinitions.h
@@ -18,7 +18,11 @@ extern "C" {
 #define LATENCY_PROFILE 0
 //#define DEBUG_LIFE_CYCLE 0
 // Internal Marcos
+
 #define NON_AVX512_SUPPORT
+//#define NON_AVX512_SUPPORT
+
+//#define VNNI_SUPPORT
 
 #ifdef __cplusplus
 #define EB_EXTERN extern "C"