Merge ~hectorcao/ubuntu/+source/ipp-crypto:ubuntu/devel into ubuntu/+source/ipp-crypto:ubuntu/devel

[Hector CAO]

Bump to new upstream version 1.0.0

https://bugs.launchpad.net/ubuntu/+source/ipp-crypto/+bug/2089569

[Simon Quigley (tsimonq2)]

review: Approve (retroactive no-op approve)

Unmerged commits

fcdf44a... by Hector CAO on 2024-11-03

changelog

08a2e43... by Hector CAO on 2024-11-25

d/control : update package names for ipcrypto-mb and libippcp

bc9a5b6... by Hector CAO on 2024-11-04

d/p: refresh patch

a79ce29... by Hector CAO on 2024-11-03

d/control : change upstream vcs and description

d73e77c... by Hector CAO on 2024-11-03

New upstream version 1.0.0

086ff37... by Hector CAO on 2024-11-03

d/watch : upstream repo renaming and versioning scheme change

diff --git a/.clang-tidy b/.clang-tidy
new file mode 100644
index 0000000..2cd04a8
--- /dev/null
+++ b/.clang-tidy
@@ -0,0 +1,24 @@
+#===============================================================================
+# Copyright (C) 2024 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the 'License');
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+# http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an 'AS IS' BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+# 
+#===============================================================================
+
+Checks: '
+    -*,
+    bugprone-infinite-loop,
+    misc-header-include-cycle,
+    readability-duplicate-include'
+
+HeaderFilterRegex: '.*(/include/ipp/|/sources/ippcp/|/examples/).*'
diff --git a/BUILD.md b/BUILD.md
index e6b0fe9..8c0074c 100644
--- a/BUILD.md
+++ b/BUILD.md
@@ -1,13 +1,13 @@
-# How to Build Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography) <!-- omit in toc -->
+# How to Build Intel® Cryptography Primitives Library <!-- omit in toc -->
 
 - [Software Requirements](#software-requirements)
     - [Common tools](#common-tools)
     - [Linux* OS](#linux-os)
     - [Windows* OS](#windows-os)
     - [macOS*](#macos)
-- [Building Intel IPP Cryptography on Linux\* OS](#building-intel-ipp-cryptography-on-linux-os)
-- [Building Intel IPP Cryptography on Windows\* OS](#building-intel-ipp-cryptography-on-windows-os)
-- [Building Intel IPP Cryptography on macOS\*](#building-intel-ipp-cryptography-on-macos)
+- [Building Intel® Cryptography Primitives Library on Linux\* OS](#building-intel-cryptography-primitives-library-on-linux-os)
+- [Building Intel® Cryptography Primitives Library on Windows\* OS](#building-intel-cryptography-primitives-library-on-windows-os)
+- [Building Intel® Cryptography Primitives Library on macOS\*](#building-intel-cryptography-primitives-library-on-macos)
 - [CMake Build Options](#cmake-build-options)
     - [Common for all operating systems](#common-for-all-operating-systems)
     - [Windows\* OS](#windows-os)
@@ -17,44 +17,48 @@
     - [How to build a 64-bit generic library without any CPU-specific optimizations?](#how-to-build-a-64-bit-generic-library-without-any-cpu-specific-optimizations)
     - [How to build two libraries with optimizations for Intel® Advanced Vector Extensions 2 and Intel® Advanced Vector Extensions 512 instruction sets?](#how-to-build-two-libraries-with-optimizations-for-intel-advanced-vector-extensions-2-and-intel-advanced-vector-extensions-512-instruction-sets)
     - [How to build a library to work in a kernel space?](#how-to-build-a-library-to-work-in-a-kernel-space)
-- [Incorporating Intel® IPP Cryptography sources into custom build system](#incorporating-intel-ipp-cryptography-sources-into-custom-build-system)
+- [Incorporating Intel® Cryptography Primitives Library sources into custom build system](#incorporating-intel-cryptography-primitives-library-sources-into-custom-build-system)
 
 
 ## Software Requirements
 ### Common tools
 - [CMake\*](https://cmake.org/download) 3.18 or higher
 - Python 3.8.1
-- The Netwide Assembler (NASM) 2.15
-- OpenSSL\* 3.0.8 or higher **OR** BoringSSL* [45cf810d](https://github.com/google/boringssl/archive/45cf810dbdbd767f09f8cb0b0fcccd342c39041f.tar.gz) **OR** Tongsuo* 8.2.1
+- The Netwide Assembler (NASM) 2.16.02
+- OpenSSL\* 3.0.8 or higher **OR** BoringSSL* [45cf810d](https://github.com/google/boringssl/archive/45cf810dbdbd767f09f8cb0b0fcccd342c39041f.tar.gz) **OR** Tongsuo* 8.3.3
 
 
 ### Linux* OS
 - [Common tools](#common-tools)
-- Intel® C++ Compiler Classic 2021.9 for Linux\* OS
+- Intel® oneAPI DPC++/C++ Compiler latest for Linux\* OS
 - GCC 8.5
 - GCC 11.4
+- GCC 14.1
 - Clang 9.0
 - Clang 12.0
 - Clang 16.0
 - GNU binutils 2.32
+> **NOTE:** [CMake\*](https://cmake.org/download) 3.22 or higher is required to build using Intel® oneAPI DPC++/C++ Compiler.
+
 ### Windows* OS
 - [Common tools](#common-tools)
-- Intel® C++ Compiler Classic 2021.9 for Windows\* OS
-- Microsoft Visual C++ Compiler\* version 19.16 provided by Microsoft Visual Studio\* 2017 version 15.9
-> **NOTE:** Support for this compiler version will be removed from Intel IPP Cryptography starting 2021.4 release. If you use it for building Intel IPP Cryptography library, please plan on migrating to a newer supported version of Microsoft Visual C++ Compiler\*.
-- Microsoft Visual C++ Compiler\* version 19.24 provided by Microsoft Visual Studio\* 2019 version 16.4
-- Microsoft Visual C++ Compiler\* version 19.30 provided by Microsoft Visual Studio\* 2022 version 17.0
+- Intel® oneAPI DPC++/C++ Compiler latest for Windows\* OS
+- Microsoft Visual C++ Compiler\* version 19.29 provided by Microsoft Visual Studio\* 2019 version 16.11
+- Microsoft Visual C++ Compiler\* version 19.30 provided by Microsoft Visual Studio\* 2022 version 17.11
 > **NOTE:** [CMake\*](https://cmake.org/download) 3.21 or higher is required to build using Microsoft Visual Studio\* 2022.
+
+> **NOTE:** [CMake\*](https://cmake.org/download) 3.22 or higher is required to build using Intel® oneAPI DPC++/C++ Compiler.
+
 ### macOS*
 - [Common tools](#common-tools)
 - Intel® C++ Compiler Classic 2021.9 for macOS\*
-## Building Intel IPP Cryptography on Linux\* OS
+## Building Intel® Cryptography Primitives Library on Linux\* OS
 
 The software was validated on:
 
 - Red Hat\* Enterprise Linux\* 8
 
-To build the Intel IPP Cryptography library on Linux\* OS, complete the following steps:
+To build the Intel® Cryptography Primitives Library on Linux\* OS, complete the following steps:
 1. Clone the source code from GitHub\* as follows:
 
     ``` bash
@@ -63,22 +67,22 @@ To build the Intel IPP Cryptography library on Linux\* OS, complete the followin
 
 2. Set the environment for one of the supported C/C++ compilers.
 
-   *Example for Intel® Compiler:*
+   *example for Intel® oneAPI DPC++/C++ Compiler:*
 
     ```bash
-    source /opt/intel/bin/compilervars.sh intel64
+    source /opt/intel/oneapi/setvars.sh intel64
     ```
 
-    For details, refer to the [Intel® C++ Compiler Developer Guide and Reference](https://www.intel.com/content/www/us/en/docs/cpp-compiler/developer-guide-reference/current/specifying-the-location-of-compiler-components.html).
+    For details, refer to the [Intel® oneAPI DPC++/C++ Compiler Developer Guide and Reference](https://www.intel.com/content/www/us/en/docs/dpcpp-cpp-compiler/developer-guide-reference/current/specifying-the-location-of-compiler-components.html).
 
 3. Run CMake\* in the command line.
 
     *Examples*:
 
-    For Intel® C++ Compiler:
+    for Intel® oneAPI DPC++/C++ Compiler:
 
     ``` bash
-    CC=icc CXX=icpc cmake CMakeLists.txt -B_build -DARCH=intel64
+    CC=icx CXX=icpx cmake CMakeLists.txt -B_build -DARCH=intel64
     ```
 
     For GCC:
@@ -98,13 +102,13 @@ To build the Intel IPP Cryptography library on Linux\* OS, complete the followin
 
     You can find the built libraries in the `<build_dir>/.build/<RELEASE|DEBUG>/lib` directory.
 
-## Building Intel IPP Cryptography on Windows\* OS
+## Building Intel® Cryptography Primitives Library on Windows\* OS
 
 The software was validated on:
 
 - Windows Server\* 2019
 
-To build the Intel IPP Cryptography library on Windows* OS, complete the following steps:
+To build the Intel® Cryptography Primitives Library on Windows* OS, complete the following steps:
 
 1. Clone the source code from GitHub\* as follows:
 
@@ -113,17 +117,18 @@ To build the Intel IPP Cryptography library on Windows* OS, complete the followi
     ```
 
 2. Set the environment variables for one of the supported C/C++ compilers.
-    For Intel® Compiler instructions, refer to the [Intel® C++ Compiler Developer Guide and Reference](https://www.intel.com/content/www/us/en/docs/cpp-compiler/developer-guide-reference/current/overview.html).
-    For MSVC* Compiler, refer to [Use the MSVC toolset from the command line](https://docs.microsoft.com/en-us/cpp/build/building-on-the-command-line?view=vs-2017).
+
+    For Intel® oneAPI DPC++/C++ Compiler instructions, refer to the [Intel® oneAPI DPC++/C++ Compiler Developer Guide and Reference](https://www.intel.com/content/www/us/en/docs/dpcpp-cpp-compiler/developer-guide-reference/current/specifying-the-location-of-compiler-components.html).
+    For MSVC* Compiler, refer to [Use the MSVC toolset from the command line](https://learn.microsoft.com/en-us/cpp/build/building-on-the-command-line?view=msvc-160).
 
 3. Run CMake\* in the command line.
 
     *Examples*:
 
-    For Intel® C++ Compiler and Visual Studio\* 2019:
+    For Intel® oneAPI DPC++/C++ Compiler and Visual Studio\* 2019:
 
     ``` bash
-    cmake CMakeLists.txt -B_build -G"Visual Studio 16 2019" -T"Intel C++ Compiler 19.2" -Ax64
+    cmake CMakeLists.txt -B_build -G"Visual Studio 16 2019" -T"Intel C++ Compiler 2024" -Ax64
     ```
 
     For MSVC\* Compiler and Visual Studio\* 2019:
@@ -145,13 +150,13 @@ To build the Intel IPP Cryptography library on Windows* OS, complete the followi
     *Build from Visual Studio\*:*
     Open the Microsoft Visual Studio\* solution `Intel(R) IPP Crypto.sln`, choose project (build target) from the Solution Explorer and run the build.
 
-## Building Intel IPP Cryptography on macOS\*
+## Building Intel® Cryptography Primitives Library on macOS\*
 
-> **NOTE:** Intel IPP Cryptography stopped macOS\* validation and maintenance based on the announcement in the [Intel IPP Cryptography 2021.9 release notes](https://www.intel.com/content/www/us/en/developer/articles/release-notes/release-notes-for-oneapi-integrated-performance-primitives.html#inpage-nav-3-1).\
-The Intel IPP Cryptography 2021.10 release is the last release validated on macOS\* 12.0.\
+> **NOTE:** Intel® Cryptography Primitives Library stopped macOS\* validation and maintenance based on the announcement in the [Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography) 2021.9 release notes](https://www.intel.com/content/www/us/en/developer/articles/release-notes/release-notes-for-oneapi-integrated-performance-primitives.html#inpage-nav-3-1).\
+The Intel® IPP Cryptography 2021.10 release is the last release validated on macOS\* 12.0.\
 For further macOS\* testing and maintenance we are relying on contributions from the community. For more details, see [Contributing Rules](./CONTRIBUTING.md).
 
-To build the Intel IPP Cryptography library on macOS\*, complete the following steps:
+To build the Intel® Cryptography Primitives Library on macOS\*, complete the following steps:
 
 1. Clone the source code from GitHub\* as follows:
 
@@ -196,12 +201,12 @@ To build the Intel IPP Cryptography library on macOS\*, complete the following s
 
 - `-B<build-dir>` - defines the build directory. This is the directory where CMake puts the generated Microsoft Visual Studio\* solution or makefiles.
 
-- `-DARCH=<ia32|intel64>` - on Linux* OS and macOS*, defines the target architecture for the build of the Intel IPP Cryptography library.
+- `-DARCH=<ia32|intel64>` - on Linux* OS and macOS*, defines the target architecture for the build of the Intel® Cryptography Primitives Library.
     > **NOTE:** On Windows* OS, use `-G`/`-A`  instead. See the description of these options [below](#windows-os-1).
 
-    > **NOTE:** Due to the significant shift in the industry towards 64-bit architecture, the support of 32-bit libraries is deprecated in the Intel IPP Cryptography 2021.9 release and targeted to be removed after one year deprecation notice period.
+    > **NOTE:** Due to the significant shift in the industry towards 64-bit architecture, the support of 32-bit libraries is deprecated in the Intel® IPP Cryptography 2021.9 release and targeted to be removed after one year deprecation notice period.
 
-- `-DMERGED_BLD:BOOL=<on|off>` - optional. Defines the configuration of the Intel IPP Cryptography library to build:
+- `-DMERGED_BLD:BOOL=<on|off>` - optional. Defines the configuration of the Intel® Cryptography Primitives Library to build:
 
   - `-DMERGED_BLD:BOOL=on`: default configuration. It includes the following steps:
     - Build of a dispatched static library with all available optimizations
@@ -213,12 +218,13 @@ To build the Intel IPP Cryptography library on macOS\*, complete the following s
 - `-DPLATFORM_LIST="<platform list>"` - optional, works only if `-DMERGED_BLD:BOOL=off` is set. Sets target platforms for the code to be compiled. See the supported platforms list [here](./OVERVIEW.md).
 
     - Example for Linux\* OS and the IA-32 architecture:
-        `-DPLATFORM_LIST="m7;s8;p8;g9;h9"`
+        `-DPLATFORM_LIST="w7;s8;p8;g9;h9"`
 
     - Example for Linux\* OS and the Intel® 64 architecture:
-        `-DPLATFORM_LIST="w7;n8;y8;e9;l9;k0"`
+        `-DPLATFORM_LIST="m7;n8;y8;e9;l9;k0;k1"`
 - `-DNO_CRYPTO_MB:BOOL=TRUE` - optional, turns off the build of [Crypto Multi Buffer library](./sources/ippcp/crypto_mb/Readme.md) and, as a consequence, removes all dependencies on OpenSSL library.
-- `-DBABASSL:BOOL=on`, `-DBORINGSSL:BOOL=on` - required only if forks of OpenSSL library are used to resolve OpenSSL dependencies - Tongsuo and BoringSSL respectively. These flags make sense when [Crypto Multi Buffer library](./sources/ippcp/crypto_mb/Readme.md) is built.
+- `-DTONGSUO:BOOL=on`, `-DBORINGSSL:BOOL=on` - required only if forks of OpenSSL library are used to resolve OpenSSL dependencies - Tongsuo and BoringSSL respectively. These flags make sense when [Crypto Multi Buffer library](./sources/ippcp/crypto_mb/Readme.md) is built.
+> **NOTE:** -DBABASSL:BOOL=on flag is deprecated and targeted to be removed in the future releases. Please use -DTONGSUO:BOOL=on instead.\*.
 - `-DIPPCP_CUSTOM_BUILD="<CPU features list>"` - optional, works only if `-DMERGED_BLD:BOOL=off` is set, i.e. only for 1CPU libraries. Enables the CPU feature dispatching mask at compile-time based on the provided list.
 
    - Currently supported by the library custom features dispatching:
@@ -228,11 +234,11 @@ To build the Intel IPP Cryptography library on macOS\*, complete the following s
         `-DIPPCP_CUSTOM_BUILD="IPPCP_AES_ON;IPPCP_CLMUL_ON"` - this combination enables Intel® AES-NI in all 1CPU libraries, which contains this code path.
     - Example of using a combination of CPU features:
         `-DIPPCP_CUSTOM_BUILD="IPPCP_AES_ON;IPPCP_CLMUL_ON;IPPCP_VAES_ON;IPPCP_VCLMUL_ON"` - in this combination the highest available feature in each 1CPU library will be enabled (e.g. for `"y8"` it’s Intel® AES-NI, for `"l9"` it's Intel® AVX2 VAES, and for `"k1"` - Intel® AVX-512 VAES)
-- `-DIPPCP_FIPS_MODE:BOOL=<on|off>` - optional. Regulates the build of FIPS-compliant Intel IPP Cryptography library.
+- `-DIPPCP_FIPS_MODE:BOOL=<on|off>` - optional. Regulates the build of FIPS-compliant Intel® Cryptography Primitives Library.
 
-  - `-DIPPCP_FIPS_MODE:BOOL=on`: enables all FIPS-compliance changes in Intel IPP Cryptography library.
-  - `-DIPPCP_FIPS_MODE:BOOL=off`: default configuration. Intel IPP Cryptography library build with such option is not FIPS-compliant.
-- `-DIPPCP_SELFTEST_USE_MALLOC:BOOL=<on|off>` - optional. Enables internal memory allocation and release using `malloc()` and `free()` functions inside Intel IPP Cryptography library selftests.
+  - `-DIPPCP_FIPS_MODE:BOOL=on`: enables all FIPS-compliance changes in Intel® Cryptography Primitives Library.
+  - `-DIPPCP_FIPS_MODE:BOOL=off`: default configuration. Intel® Cryptography Primitives Library build with such option is not FIPS-compliant.
+- `-DIPPCP_SELFTEST_USE_MALLOC:BOOL=<on|off>` - optional. Enables internal memory allocation and release using `malloc()` and `free()` functions inside Intel® Cryptography Primitives Library selftests.
   - `-DIPPCP_SELFTEST_USE_MALLOC:BOOL=on`: memory management is held by FIPS selftests, all processing APIs should be called with input parameters equal to `NULL`.
   - `-DIPPCP_SELFTEST_USE_MALLOC:BOOL=off`: default configuration. Memory management is held by customer's application, all processing APIs should be called with work buffers of the valid length.
 - `-DMBX_FIPS_MODE:BOOL=<on|off>` - optional. Regulates the build of FIPS-compliant  Crypto Multi-buffer Library.
@@ -247,10 +253,10 @@ To build the Intel IPP Cryptography library on macOS\*, complete the following s
 - `-G"<tool-chain-generator>"` - defines the native build system CMake will generate from the input files.
   Refer to CMake [documentation](https://cmake.org/cmake/help/latest/manual/cmake-generators.7.html#visual-studio-generators) for the Visual Studio\* generators options.
 
-- `-A<x64|Win32>` - for Visual Studio\* 2019+, defines the target architecture for the build of the Intel IPP Cryptography library.
+- `-A<x64|Win32>` - for Visual Studio\* 2019+, defines the target architecture for the build of the Intel® Cryptography Primitives Library.
 
 - `-T<Compiler>` - defines the compiler for building.
-  For example, to use Intel® Compiler, specify `-T"Intel C++ Compiler 19.1"`.
+  For example, to use Intel® oneAPI DPC++/C++ Compiler, specify `-T"Intel C++ Compiler 2024"`.
 
 > **NOTE:** Refer to CMake [documentation](https://cmake.org/cmake/help/latest/manual/ccmake.1.html) for more information on these options.
 
@@ -264,10 +270,6 @@ To build the Intel IPP Cryptography library on macOS\*, complete the following s
 
 ## CMake Commands FAQ
 
-### How to build a 32-bit library?
-
-`cmake CMakeLists.txt -B_build -DARCH=ia32`
-
 ### How to build a 64-bit generic library without any CPU-specific optimizations?
 
 `cmake CMakeLists.txt -B_build -DARCH=intel64 -DMERGED_BLD:BOOL=off -DPLATFORM_LIST=mx`
@@ -283,9 +285,9 @@ To build the Intel IPP Cryptography library on macOS\*, complete the following s
 ### How to specify path to OpenSSL\*
 `cmake CMakeLists.txt -B_build -DARCH=intel64 -DOPENSSL_INCLUDE_DIR=/path/to/openssl/include -DOPENSSL_LIBRARIES=/path/to/openssl/lib -DOPENSSL_ROOT_DIR=/path/to/openssl`
 
-## Incorporating Intel® IPP Cryptography sources into custom build system
+## Incorporating Intel® Cryptography Primitives Library sources into custom build system
 
-You can include Intel IPP Cryptography sources into some arbitrary project's CMake build system and build them with it.
+You can include Intel® Cryptography Primitives Library sources into some arbitrary project's CMake build system and build them with it.
 
 Here is the minimal working example:
 
@@ -294,28 +296,32 @@ cmake_minimum_required(VERSION 3.18)
 
 project("test_proj")
 
-# `crypto` is the repository root folder of Intel IPP Cryptography
+# `crypto` is the repository root folder of Intel® Cryptography Primitives Library
 add_subdirectory(crypto)
 include_directories(crypto/include)
 
 # 'main.cpp' is some arbitrary project's source file
 add_executable("test_proj" main.cpp)
-# `ippcp_s` is the target name of static library in the Intel IPP Cryptography build system.
+# `ippcp_s` is the target name of static library in the Intel® Cryptography Primitives Library build system.
 # This static library will be built automatically, when you build your project.
 target_link_libraries("test_proj" "ippcp_s")
 ```
 
-Also you can use CMake module to find the Intel IPP Cryptography library installed on the system. The module location is `examples/FindIPPCrypto.cmake` and here is the example of its usage:
+Also you can use the CMake module to find the Intel® Cryptography Primitives Library installed on the system. The module location is `examples/FindIPPCrypto.cmake` and here is the example of its usage:
 
 ``` bash
 find_package(IPPCrypto REQUIRED MODULE)
 
 if (NOT IPPCRYPTO_FOUND)
-   message(FATAL_ERROR "No Intel IPP Cryptography library found on the system.")
+   message(FATAL_ERROR "No Intel® Cryptography Primitives Library found on the system.")
 endif()
 
-# If Intel IPP Cryptography is found, the following variables will be defined:
+# If Intel® Cryptography Primitives Library is found, the following variables will be defined:
 #     `IPPCRYPTO_LIBRARIES` - static library name
-#     `IPPCRYPTO_INCLUDE_DIRS` - path to Intel IPP Cryptography headers
+#     `IPPCRYPTO_INCLUDE_DIRS` - path to Intel® Cryptography Primitives Library headers
 #     `IPPCRYPTO_ROOT_DIR` - library root dir (a folder with 'include' and 'lib' directories)
 ```
+
+### How to run Intel® IPP Cryptography with clang-tidy?
+
+`CC=clang CXX=clang++ cmake CMakeLists.txt -B_build -DARCH=intel64 -DCRYPTO_USE_CLANG_TIDY:BOOL=on`
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index a3d628b..c51d085 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,17 @@
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
-
-This is a list of notable changes to Intel(R) IPP Cryptography, in reverse chronological order.
+# Intel® Cryptography Primitives Library
+
+This is a list of notable changes to Intel® Cryptography Primitives Library, in reverse chronological order.
+
+## Intel(R) Cryptography Primitives Library 1.0.0
+- Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography) was renamed to Intel(R) Cryptography Primitives Library.
+- Added IPPCP SM3 hash algorithm optimization with the new instruction set (SM3-NI) for Lunar Lake and Arrow Lake CPUs.
+- Added Intel® AVX-IFMA RSA implementation to Crypto Multi buffer library.
+- Fixed bug in IceLake optimization (`k1` branch) of ECDSA signature function caused by incorrect processing of R and S component's size and sign.
+- Added FIPS selftest for Leighton-Micali Hash-Based Signatures(LMS) verification algorithm.
+- Added examples for SM3 Hash / LMS post-quantum verification / NIST Curve P-256 ECDSA signature generation algorithms.
+- Changed `-DBABASSL:BOOL=on` CMake build option to `-DTONGSUO:BOOL=on` for Tongsuo library.
+- Removed API that were deprecated in Intel® Integrated Performance Primitives Cryptography 2020 Update1. More details can be found in [DEPRECATION_NOTES.md](./DEPRECATION_NOTES.md). Please note that `ippsHash<GetSize/Init/Duplicate/Pack/Unpack/Update/GetTag/Final/HashMessage>` API still remain in the library.
+- Removed support for SSSE3(`s8` for ia32 and `n8` for intel64) and AVX(`g9` for ia32 and `e9` for intel64) code-paths. Execution was moved to SSE3(`w7` for ia32 and `m7` for intel64) and SSE4.2(`p8` for ia32 and `y8` for intel64) respectively. There is still the possibility to use 1cpu headers and 1cpu libraries without breaking change for 1 year but some performance drops are expected.
 
 ## Intel(R) IPP Cryptography 2021.12.1
 - Added `FIPS_CUSTOM_IPPCP_API_HEADER` build flag to support FIPS self-tests for a specific use case when Custom Library Tool is used with custom prefix for IPPCP API.
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 27d9d3a..6d0d978 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -15,23 +15,22 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
 cmake_minimum_required(VERSION 3.12)
 
 include("${CMAKE_CURRENT_SOURCE_DIR}/sources/cmake/ippcp-utils.cmake")
-ippcp_getlibversion("${CMAKE_CURRENT_SOURCE_DIR}/include/ippversion.h")
+ippcp_getlibversion("${CMAKE_CURRENT_SOURCE_DIR}/include/ippcpversion.h")
 if ((NOT DEFINED IPPCP_VERSION_MAJOR) OR
     (NOT DEFINED IPPCP_VERSION_MINOR) OR
     (NOT DEFINED IPPCP_VERSION_UPDATE) OR
     (NOT DEFINED IPPCP_INTERFACE_VERSION_MAJOR) OR
     (NOT DEFINED IPPCP_INTERFACE_VERSION_MINOR))
-    message(WARNING "Cannot parse version from ippversion.h file. The project might be corrupted.")
+    message(WARNING "Cannot parse version from ippcpversion.h file. The project might be corrupted.")
 endif()
 
-set(PROJECT_FULL_NAME "Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)")
-set(PROJECT_NAME "Intel(R) IPP Crypto")
+set(PROJECT_FULL_NAME "Intel® Cryptography Primitives Library")
 set(PROJECT_VERSION ${IPPCP_VERSION})
 
 set(LIB_NAME ippcp)
@@ -51,7 +50,7 @@ if("${CMAKE_GENERATOR}" STREQUAL "NMake Makefiles")
   endif()
 endif()
 
-project(${PROJECT_NAME}
+project(${PROJECT_FULL_NAME}
         VERSION ${PROJECT_VERSION}
         LANGUAGES C CXX)
 
@@ -148,6 +147,12 @@ if(${CMAKE_BUILD_TYPE} STREQUAL "Debug")
   set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG}")
 endif()
 
+if (CRYPTO_USE_CLANG_TIDY AND ${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang" AND ${CMAKE_CXX_COMPILER_VERSION} VERSION_GREATER_EQUAL "12.0.0")
+    find_program(DO_CLANG_TIDY NAMES clang-tidy)
+    set(CMAKE_CXX_CLANG_TIDY ${DO_CLANG_TIDY})
+    set(CMAKE_C_CLANG_TIDY ${DO_CLANG_TIDY})
+endif ()
+
 message (STATUS "PROJECT ............................... " ${PROJECT_FULL_NAME})
 message (STATUS "CMAKE_BINARY_DIR ...................... " ${CMAKE_BINARY_DIR})
 message (STATUS "CMAKE_OUTPUT_DIR ...................... " ${CMAKE_OUTPUT_DIR})
@@ -163,6 +168,12 @@ message (STATUS "ARCH .................................. " ${ARCH})
 message (STATUS "DYNAMIC_LIB ........................... " ${DYNAMIC_LIB})
 message (STATUS "CMAKE_INSTALL_PREFIX .................. " ${CMAKE_INSTALL_PREFIX})
 
+if(CRYPTO_USE_CLANG_TIDY)
+  message (STATUS "CLANG_TIDY ............................ on")
+else()
+  message (STATUS "CLANG_TIDY ............................ off")
+endif()
+
 if(Python_Interpreter_FOUND)
   message (STATUS "PYTHON_VERSION_STRING ................. " ${Python_VERSION})
 else()
@@ -221,13 +232,18 @@ else()
 endif()
 
 add_subdirectory(sources/ippcp)
-if(EXISTS "${IPP_CRYPTO_DIR}/tests/")
-  add_subdirectory(tests)
-endif()
-if(EXISTS "${IPP_CRYPTO_DIR}/perf_tests/")
-  add_subdirectory(perf_tests)
+
+if (NOT (CRYPTO_USE_CLANG_TIDY))
+
+  if(EXISTS "${IPP_CRYPTO_DIR}/tests/")
+    add_subdirectory(tests)
+  endif()
+  if(EXISTS "${IPP_CRYPTO_DIR}/perf_tests/")
+    add_subdirectory(perf_tests)
+  endif()
 endif()
 
+
 if(BUILD_EXAMPLES)
   # This helps to organize examples projects structure in IDE by folders
   set_property(GLOBAL PROPERTY USE_FOLDERS ON)
diff --git a/CONST_TIME_EXECUTION_TESTING.md b/CONST_TIME_EXECUTION_TESTING.md
index 1bf9c7d..9acc211 100644
--- a/CONST_TIME_EXECUTION_TESTING.md
+++ b/CONST_TIME_EXECUTION_TESTING.md
@@ -1,12 +1,12 @@
-# Scope of the Constant-time execution testing of Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Scope of the Constant-time execution testing of Intel® Cryptography Primitives Library
 
 - [General information](#general)
 - [Scope for ippcp library](#ippcp)
 - [Scope for crypto_mb library](#cryptomb)
 
 ## General information <div id = 'general'>
-- Testing is conducted under Linux for 64-bit Intel® IPP Cryptography built with the compilers listed in [Build](./BUILD.md).
-- Tested platforms: w7, n8, y8, e9, l9, k0 (see the supported platforms list [here](./OVERVIEW.md#target-optimization-codes-in-function-names)).
+- Testing is conducted under Linux for 64-bit Intel® Cryptography Primitives Library built with the compilers listed in [Build](./BUILD.md).
+- Tested platforms: m7, y8, l9, k0, k1 (see the supported platforms list [here](./OVERVIEW.md#target-optimization-codes-in-function-names)).
 - Testing scope described below is guaranteed to pass for **`release`** branches. This is not guaranteed for the **`develop`** branch ([branches description](./OVERVIEW.md#branches-description))
 - Information about Pin-Based Constant Execution Checker can be found [here](https://github.com/intel/pin_based_cec)
 
@@ -69,6 +69,7 @@
 |      ippsGFpMul_PE       |                                             -                                              |
 |     ippsGFpMultiExp      |                                             -                                              |
 |        ippsGFpNeg        |                                             -                                              |
+|        ippsGFpSqr        |                                             -                                              |
 |        ippsGFpSub        |                                             -                                              |
 |      ippsGFpSub_PE       |                                             -                                              |
 |     ippsHMACInit_rmf     | Different hashes:<br>sha1, sha256, sha224, sha384, sha512, <br>sha512-256, sha512-224, sm3 |
@@ -150,5 +151,18 @@
 |         mbx_sm4_encrypt_ofb_mb16         |                           -                           |
 |       mbx_sm4_encrypt_cfb128_mb16        |                           -                           |
 |       mbx_sm4_decrypt_cfb128_mb16        |                           -                           |
+|       mbx_sm4_xts_encrypt_mb16           |                           -                           |
+|       mbx_sm4_xts_decrypt_mb16           |                           -                           |
+|       mbx_sm4_ccm_init_mb16              |                           -                           |
+|       mbx_sm4_ccm_update_aad_mb16        |                           -                           |
+|       mbx_sm4_ccm_encrypt_mb16           |                           -                           |
+|       mbx_sm4_ccm_decrypt_mb16           |                           -                           |
+|       mbx_sm4_ccm_get_tag_mb16           |                           -                           |
+|       mbx_sm4_gcm_init_mb16              |                           -                           |
+|       mbx_sm4_gcm_update_iv_mb16         |                           -                           |
+|       mbx_sm4_gcm_update_aad_mb16        |                           -                           |
+|       mbx_sm4_gcm_encrypt_mb16           |                           -                           |
+|       mbx_sm4_gcm_decrypt_mb16           |                           -                           |
+|       mbx_sm4_gcm_get_tag_mb16           |                           -                           |
 |        mbx_x25519_public_key_mb8         |                           -                           |
 |              mbx_x25519_mb8              |                           -                           |
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a417079..dfaa0ef 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,9 +1,9 @@
-Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography) Contribution Rules
-===============================================================
+Intel® Cryptography Primitives Library Contribution Rules
+=========================================================
 
 ## How to Contribute
 
-We welcome community contributions to Intel® IPP Cryptography!
+We welcome community contributions to Intel® Cryptography Primitives Library!
 
 If you have an idea how to improve the product:
 
@@ -12,9 +12,9 @@ If you have an idea how to improve the product:
 
 
 
-## Intel® IPP Cryptography repository scheme
+## Intel® Cryptography Primitives Library repository scheme
 
-Intel® IPP Cryptography supports two repositories that are named as "Public Repository" and "Inner Repository". Privately hosted "Inner Repository" is required for extensive internal testing and experimental features development.
+Intel® Cryptography Primitives Library supports two repositories that are named as "Public Repository" and "Inner Repository". Privately hosted "Inner Repository" is required for extensive internal testing and experimental features development.
 
 Existing automation guarantees regular synchronization of repositories.
 
@@ -29,7 +29,7 @@ Existing automation guarantees regular synchronization of repositories.
 </pre>
 
 ## License
-Intel® IPP Cryptography is licensed under the terms in LICENSE <https://github.com/intel/ipp-crypto/blob/develop/LICENSE>. By contributing to the project, you agree to the license and copyright terms therein and release your contribution under these terms.
+Intel® Cryptography Primitives Library is licensed under the terms in LICENSE <https://github.com/intel/ipp-crypto/blob/develop/LICENSE>. By contributing to the project, you agree to the license and copyright terms therein and release your contribution under these terms.
 
 ## Developer Certification of Origin (DCO)
 We encourage you to use Signed-off-by feature to comply with [Developer Certification of Origin (DCO)](https://developercertificate.org/).  
@@ -42,9 +42,9 @@ The name in the commit message Signed-off-by line and your email must match the 
 ## Contribution Flow
 
 - Contributor creates fork from develop, commits the changes into the created branch, opens a PR and requests a review.
-- Contributor applies feedback provided by Intel® IPP Cryptography repository maintainer in opened PR.
-- Intel® IPP Cryptography repository maintainer must ensure that the code is safe for internal execution, get code into inner repository and run private testing.
-- Intel® IPP Cryptography repository maintainer merges the changes "as is" from inner repository, when private testing is passed.
+- Contributor applies feedback provided by Intel® Cryptography Primitives Library repository maintainer in opened PR.
+- Intel® Cryptography Primitives Library repository maintainer must ensure that the code is safe for internal execution, get code into inner repository and run private testing.
+- Intel® Cryptography Primitives Library repository maintainer merges the changes "as is" from inner repository, when private testing is passed.
 > **Note**
 > Original PR is closed because merging PRs on the external GitHub repo isn't supported.
 
@@ -74,7 +74,7 @@ The name in the commit message Signed-off-by line and your email must match the 
 
 ## Pull Request Checklist
 Before sending your pull requests, ensure that:
- - Intel® IPP Cryptography builds successfully with proposed changes using one of the compilers listed in [Build](./BUILD.md). Please specify which exact compiler was used.
+ - Intel® Cryptography Primitives Library builds successfully with proposed changes using one of the compilers listed in [Build](./BUILD.md). Please specify which exact compiler was used.
  - Relevant documentation are added (for example CHANDELOG.md, README.md etc)
  - For new features make sure that
     - All new files are covered by copyrights.
diff --git a/DEPRECATION_NOTES.md b/DEPRECATION_NOTES.md
index 3ef6475..138bb66 100644
--- a/DEPRECATION_NOTES.md
+++ b/DEPRECATION_NOTES.md
@@ -1,10 +1,25 @@
-# Deprecated API in Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Deprecated API in Intel® Cryptography Primitives Library
 
-This document describes deprecated API in different Intel IPP Cryptography versions and recommendations for transition.
+This document describes deprecated API in different Intel® Cryptography Primitives Library versions and recommendations for transition.
 
-The deprecated API means it is obsolete and will be removed in one of future Intel IPP Cryptography releases. If you have any concerns, please use the following link for opening a ticket and providing feedback:  <https://supporttickets.intel.com.>
+The deprecated API means it is obsolete and will be removed in one of future Intel® Cryptography Primitives Library releases. If you have any concerns, please use the following link for opening a ticket and providing feedback:  <https://supporttickets.intel.com.>
 
-## 2020 Update1 (branch [ipp-crypto_2020_update1](https://github.com/intel/ipp-crypto/tree/ipp-crypto_2020_update1))
+## Intel® Cryptography Primitives Library v1.0.0
+
+### Service Functions
+
+| Deprecated                                        |                    Recommended replacement                     |
+| :------------------------------------------------ | :------------------------------------------------------------: |
+| ippcpGetNumThreads                                |                      N/A                                       |
+| ippcpGetEnabledNumThreads                         |                      N/A                                       |
+| ippcpSetNumThreads                                |                      N/A                                       |
+| ippcpGetLibVersion                                |                      cryptoGetLibVersion                       |
+
+### Deprecated Optimizations
+
+The code paths n8/s8 (Intel® SSSE3) and g9/e9 (Intel® AVX) are deprecated and removed from the merged build of Intel® Cryptography Primitives Library, lower optimizations are used instead. 1cpu headers are still available for all code paths. These branches can also be built as 1cpu libraries if specified in the platform list, e.g. `-DMERGED_BLD:BOOL=off -DPLATFORM_LIST=s8;e9`.
+
+## Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography) 2020 Update1 (branch [ipp-crypto_2020_update1](https://github.com/intel/ipp-crypto/tree/ipp-crypto_2020_update1))
 
 ### Hash Functionality
 
diff --git a/OVERVIEW.md b/OVERVIEW.md
index 0cf934e..7e1c85e 100644
--- a/OVERVIEW.md
+++ b/OVERVIEW.md
@@ -1,4 +1,4 @@
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography) Library Overview <!-- omit in toc -->
+# Intel® Cryptography Primitives Library Overview <!-- omit in toc -->
 
 - [Repository Structure](#repository-structure)
   - [Branches Description](#branches-description)
@@ -19,7 +19,7 @@
     - [Dynamic Library with Custom functionality](#dynamic-library-with-custom-functionality)
 
 <!-- Images List -->
-[sha256-dispatching]: ./data/images/README-pictures-0-dispatcher.png  "Intel IPP Crypto function dispatching scheme"
+[sha256-dispatching]: ./data/images/README-pictures-0-dispatcher.png  "Intel® Cryptography Primitives Library function dispatching scheme"
 [library configurations]: ./data/images/README-pictures-1-library-configurations.png  "Library configurations picture"
 [build targets]: ./data/images/README-pictures-1a-build-targets.png  "Build targets picture"
 [merged library]: ./data/images/README-pictures-2-merged-library.png  "Merged library scheme"
@@ -31,26 +31,43 @@
 ## Repository Structure
 
 ``` bash
-├── CHANGELOG.md
-├── CMakeLists.txt                               < Main CMake file
-├── examples                                     < Examples of the library usage
-├── include                                      < Public headers
-├── LICENSE
-├── README.md
+├── data/images
+├── examples                                 < Examples of the library usage
+├── include                                  < Public headers
 ├── sources
-│   ├── cmake                                    < OS-specific CMake files
+│   ├── cmake                                < OS-specific CMake files
 │   │   ├── linux
 │   │   ├── macosx
 │   │   └── windows
-│   ├── dispatcher                               < CPU dispatcher generator
-│   ├── gen_cpu_spc_header                       < Single CPU headers generator
-│   ├── include                                  < Internal headers
-│   └── ippcp                                    < C-sources
-│       ├── asm_ia32                             < IA-32 Assembler sources
-│       ├── asm_intel64                          < Intel® 64 Assembler sources
-│       └── ifma_rsa_mb                          < Sources of RSA IFMA Multi-buffer library
-└── tools
-    └── ipp_custom_library_tool_python           < Custom Library Tool
+│   ├── dispatcher                           < CPU dispatcher generator
+│   ├── gen_cpu_spc_header                   < Single CPU headers generator
+│   ├── include                              < Internal headers
+│   └── ippcp                                < C-sources
+│       ├── asm_ia32                         < IA-32 Assembler sources
+│       ├── asm_intel64                      < Intel® 64 Assembler sources
+│       ├── crypto_mb                        < Sources of the Crypto Multi-buffer library
+│       ├── fips_cert
+│       ├── gfpec
+│       ├── hash
+│       ├── lms
+│       └── xmss
+├── tools
+|   └── ipp_custom_library_tool_python       < Custom Library Tool
+├── .clang-format
+├── .clang-tidy
+├── BUILD.md
+├── CHANGELOG.md
+├── CMakeLists.txt                           < Main CMake file
+├── CONST_TIME_EXECUTION_TESTING.md          < Information about security testing
+├── CONTRIBUTING.md
+├── DEPRECATION_NOTES.md
+├── LICENSE
+├── OVERVIEW.md
+├── README.md
+├── README_FIPS.md                           < FIPS compliance guide
+├── SECURITY.md
+├── SUPPORT.md
+└── THIRD-PARTY-PROGRAMS.txt
 ```
 
 ### Branches Description
@@ -63,13 +80,42 @@ Contains code that may not be fully functional and that Intel may substantially 
 
 ### CPU Dispatching
 
-For the best performance, Intel IPP Cryptography uses multiple implementations of each function, optimized for various CPUs, and the [library version targeted for any CPU](#all-cpus-library) contains all of these implementations.
+For the best performance, Intel® Cryptography Primitives Library uses multiple implementations of each function, optimized for various CPUs, and the [library version targeted for any CPU](#all-cpus-library) contains all of these implementations.
 
 With the dispatcher, the library detects an available CPU in a runtime and chooses the best for the current hardware version of a function. The process of dispatching is transparent and you can always call a generic function as illustrated at the picture below.
 
-![Dispatcher picture][sha256-dispatching]
+```mermaid
+flowchart LR
+    classDef class1 fill:#0054AE, stroke:none, color:#FFFFFF
+
+    function["ippsAES_GCMEncrypt()"]:::class1
+
+    %% Subgraph for Merged Library
+    subgraph ML[**Merged Library**]
+        dispatcher["Dispatcher"]:::class1
 
-The prefix before the function name ("m7_", "n8_", etc) is a naming convention for the function implementations that are included in the [library with dispatcher](#all-cpus-library). It refers to the CPU instruction set for which the function is optimized (for all available prefixes see the [table](#target-optimization-codes-in-function-names) below).
+        m7["m7_ippsAES_GCMEncrypt()"]:::class1
+        y8["y8_ippsAES_GCMEncrypt()"]:::class1
+        l9["l9_ippsAES_GCMEncrypt()"]:::class1
+        k0["k0_ippsAES_GCMEncrypt()"]:::class1
+        k1["k1_ippsAES_GCMEncrypt()"]:::class1
+
+        %% Connections
+        dispatcher == SSE3==> m7
+        dispatcher == SSSE4.2 ==> y8
+        dispatcher == AVX2 ==> l9
+        dispatcher == AVX512 (formerly codenamed SkyLake) ==> k0
+        dispatcher == AVX512 (formerly codenamed IceLake) ==> k1
+    end
+
+    style ML fill:#15BCEF, stroke:#15BCEF, color:#FFFFFF
+
+    function ==> dispatcher
+
+    linkStyle 0,1,2,3,4,5 stroke:#FFE500
+```
+
+The prefix before the function name ("m7_", "y8_", etc) is a naming convention for the function implementations that are included in the [library with dispatcher](#all-cpus-library). It refers to the CPU instruction set for which the function is optimized (for all available prefixes see the [table](#target-optimization-codes-in-function-names) below).
 
 The dispatcher is designed to add no performance overhead when the library is initialized, in other words, when CPU features are detected. You can initialize the library either explicitly in advance by calling the dedicated function [ippcpInit()](https://www.intel.com/content/www/us/en/docs/ipp-crypto/developer-reference/current/init.html) or it will be done implicitly during the first call of any function of the library.
 
@@ -82,14 +128,12 @@ By default, the dispatcher chooses the most appropriate optimization for the cur
 | px                        | mx                     | Generic code without hardware specific optimizations suitable for any CPU                                          |
 | w7                        | -                      | Optimized for processors with Intel® Streaming SIMD Extensions 2 (Intel® SSE2)                                     |
 | -                         | m7                     | Optimized for processors with Intel® SSE3                                                                          |
-| s8                        | n8                     | Optimized for processors with Supplemental Streaming SIMD Extensions 3 (SSSE3)                                     |
 | p8                        | y8                     | Optimized for processors with Intel® SSE4.2                                                                        |
-| g9                        | e9                     | Optimized for processors with Intel® Advanced Vector Extensions (Intel® AVX)                                       |
 | h9                        | l9                     | Optimized for processors with Intel® Advanced Vector Extensions 2 (Intel® AVX2)                                    |
 | -                         | k0                     | Optimized for processors with Intel® Advanced Vector Extensions 512 (Intel® AVX-512) (formerly codenamed SkyLake)  |
 | -                         | k1                     | Optimized for processors with Intel® Advanced Vector Extensions 512 (Intel® AVX-512) (formerly codenamed IceLake)  |
 
-> **NOTE:** Due to the significant shift in the industry towards 64-bit architecture, the support of 32-bit libraries is deprecated in the Intel IPP Cryptography 2021.9 release and targeted to be removed after one year deprecation notice period.
+> **NOTE:** Due to the significant shift in the industry towards 64-bit architecture, the support of 32-bit libraries is deprecated in the Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography) 2021.9 release. No new features (only critical security fixes) are targeted for 32-bit libraries and testing scope is limited by Linux OS & Clang compiler.
 
 ### CPU Feature Dispatching
 
@@ -106,6 +150,7 @@ List of CPU feature subsets that the library has special optimizations for:
 - Intel AVX-512/AVX2 VAES
 - Intel AVX-512 IFMA
 - Intel AVX-512 GFNI
+- SM3-NI
 
  > **NOTE:** For some features there is also an opportunity to force their dispatching inside the 1CPU libraries manually during the compile time. For more information please, refer to [common for all operating systems CMake build options](./BUILD.md/#common-for-all-operating-systems).
 
@@ -115,7 +160,7 @@ To leave only specific ISA when linking with an [All CPUs Static Library](#all-c
 
 ## Library Configurations
 
-The Intel IPP Cryptography library supports configurations by:
+The Intel® Cryptography Primitives Library supports configurations by:
 
 1) [*Linkage Mode*](#linkage-mode): to produce a static or dynamic library
 
@@ -133,7 +178,61 @@ The Intel IPP Cryptography library supports configurations by:
 
 All possible configuration combinations are shown in the picture below.
 
-![Library configurations picture][library configurations]
+
+```mermaid
+flowchart
+
+    %% Style for classes
+    classDef class1 fill:#0054AE, stroke:none, color:#FFFFFF
+    classDef class2 fill:#0054AE, stroke:none, color:#FFFFFF
+
+    library["Intel® Cryptography Primitives Library"]:::class1
+
+    %% Subgraph for the picture
+    subgraph base[" "]
+        subgraph first["Link type "]
+            Static:::class2
+            Dynamic:::class2
+        end
+
+        subgraph second["Position Independent Code"]
+            non-PIC:::class2
+            PIC:::class2
+        end
+
+        subgraph third["Dispatcher"]
+            allCPU["All CPU + Disptacher"]:::class2
+            singleCPU[Single CPU]:::class2
+        end
+
+        subgraph forth["Library Components"]
+            customFunc["Custom Functionality"]:::class2
+            allFunc["All Functionality"]:::class2
+        end
+
+        %% Connections
+        library ==> Static
+        library ==> Dynamic
+
+        Static ==> non-PIC
+        Static & Dynamic ==> PIC
+
+        second ==> third
+
+        allCPU ==> customFunc
+        singleCPU & allCPU ==> allFunc
+    end
+
+    %% Style for subgraphs
+    style first fill:#15BCEF, stroke:#15BCEF, color:#FFFFFF
+    style second fill:#15BCEF, stroke:#15BCEF, color:#FFFFFF
+    style third fill:#15BCEF, stroke:#15BCEF, color:#FFFFFF
+    style forth fill:#15BCEF, stroke:#15BCEF, color:#FFFFFF
+
+    linkStyle 0,1,2,3,4,5,6,7,8 stroke:#FFE500
+
+    style base fill:none, stroke:#15BCEF, stroke-width:3px
+```
 
 ### Linkage Mode
 
@@ -145,7 +244,7 @@ The corresponding build target names for the libraries are shown at the picture 
 
 ### Code Position
 
-Be default, the Intel IPP Cryptography library is built with the [Position Independent Code (PIC)](https://en.wikipedia.org/wiki/Position-independent_code) option.
+Be default, the Intel® Cryptography Primitives Library is built with the [Position Independent Code (PIC)](https://en.wikipedia.org/wiki/Position-independent_code) option.
 
 But on Linux* OS, when the library is supposed to work in kernel space, it is possible to compile the static library in a non-PIC mode. For more information about build options, refer to the [Linux* OS build options](./BUILD.md).
 
@@ -155,7 +254,66 @@ But on Linux* OS, when the library is supposed to work in kernel space, it is po
 
 Each function of the library is built in several instances with optimizations for each supported instruction set (see example for the `func2` function in green). Those functions instances are all included into a single library along with the [dispatcher](#dispatcher) that lets the library choose right function instance depending on current CPU. Such library build is called a merged library build.
 
-![Merged library picture][merged library]
+```mermaid
+flowchart TD
+    %% Style for classes
+    classDef class1 fill:#0054AE, stroke:none, color:#FFFFFF, font-size:16pt
+    classDef class2 fill:#0054AE, stroke:none, color:#FFFFFF, font-size:12pt
+        subgraph base[" "]
+
+            Dispatcher["Dispatcher"]:::class1
+
+            subgraph m7_graph["SSE3 version"]
+                m7_1["m7_func1"]:::class2
+                m7_2["m7_func2"]:::class2
+                m7_3["m7_<...>"]:::class2
+                m7_4["m7_funcN"]:::class2
+            end
+
+            subgraph y8_graph["SSE4.2 version"]
+               y8_1["y8_func1"]:::class2
+                y8_2["y8_func2"]:::class2
+                y8_3["y8_<...>"]:::class2
+                y8_4["y8_funcN"]:::class2
+            end
+
+            subgraph l9_graph["AVX2 version"]
+                l9_1["l9_func1"]:::class2
+                l9_2["l9_func2"]:::class2
+                l9_3["l9_<...>"]:::class2
+                l9_4["l9_funcN"]:::class2
+            end
+
+            subgraph k0_graph["AVX512 k0 version"]
+                k0_1["k0_func1"]:::class2
+                k0_2["k0_func2"]:::class2
+                k0_3["k0_<...>"]:::class2
+                k0_4["k0_funcN"]:::class2
+            end
+
+            subgraph k1_graph["AVX512 k1 version"]
+                k1_1["k1_func1"]:::class2
+                k1_2["k1_func2"]:::class2
+                k1_3["k1_<...>"]:::class2
+                k1_4["k1_funcN"]:::class2
+            end
+
+            Dispatcher ~~~ m7_graph
+            Dispatcher ~~~ y8_graph
+            Dispatcher ~~~ l9_graph
+            Dispatcher ~~~ k0_graph
+            Dispatcher ~~~ k1_graph
+        end
+
+    %% Style for subgraphs
+    style m7_graph fill:#15BCEF, stroke:#15BCEF, color:#FFFFFF
+    style y8_graph fill:#15BCEF, stroke:#15BCEF, color:#FFFFFF
+    style l9_graph fill:#15BCEF, stroke:#15BCEF, color:#FFFFFF
+    style k0_graph fill:#15BCEF, stroke:#15BCEF, color:#FFFFFF
+    style k1_graph fill:#15BCEF, stroke:#15BCEF, color:#FFFFFF
+
+    style base fill:none, stroke:#15BCEF, stroke-width:3px, color:#0054AE, font-size:16pt
+```
 
 The advantage of this configuration is that the library works on any CPU.
 
@@ -167,6 +325,8 @@ The build system produces several separate libraries each optimized for its own 
 
 To specify for what instruction set targeted libraries must be produced, use the `PLATFORM_LIST` CMake variable. It contains semicolon-delimited list of CPU codes (for the complete list of codes see the table in [this](#target-optimization-codes-in-function-names) section).
 
+> **NOTE:** Platforms n8 (optimized for processors with Supplemental Streaming SIMD Extensions 3 (SSSE3)) and e9 (optimized for processors with Intel® Advanced Vector Extensions (Intel® AVX)) have been deprecated but are still supported in the specific ISA library build. Support for these platforms is targeted to be removed in a future release.
+
 For example, to create two libraries - one with SSE4.2 optimizations and another with Intel AVX-512 optimizations, specify `-DPLATFORM_LIST="y8;k0"`.
 
 ![CPU specific libraries picture][CPU-specific libraries]
@@ -193,13 +353,13 @@ It is important to ensure that both processor and operating system supports full
 
 ### Functionality
 
-By default, Intel IPP Cryptography libraries (both static and dynamic) contain all functionality that exists in the product. But when footprint size matters, the library can contain only required functionality and have no unused code.
+By default, Intel® Cryptography Primitives Library (both static and dynamic libraries) contain all functionality that exists in the product. But when footprint size matters, the library can contain only required functionality and have no unused code.
 
 #### Static Library with Custom functionality
 
 With the static linking having only required functionality in the library is not so actual as leaving only those parts of a library that are used by application, is automatically managed by linker.
 
-Considering Intel IPP Cryptography design that implies minimal internal dependencies, the application linked with the Intel IPP Cryptography static library contains only relevant library functionality, and has minimal footprint size.
+Considering Intel® Cryptography Primitives Library design that implies minimal internal dependencies, the application linked with the static Intel® Cryptography Primitives Library contains only relevant library functionality, and has minimal footprint size.
 
 #### Dynamic Library with Custom functionality
 
@@ -207,4 +367,4 @@ To build your own dynamic library containing only the functionality that is nece
 
 The tool is located in the `tools/ipp_custom_library_tool_python` directory.
 
-Please refer to the [tool documentation](https://www.intel.com/content/www/us/en/docs/ipp/developer-guide-oneapi/current/ipp-custom-library-tool.html) for more information.
+Please refer to the [tool documentation](https://www.intel.com/content/www/us/en/docs/ipp/developer-guide-reference/current/ipp-custom-library-tool.html) for more information.
diff --git a/README.md b/README.md
index bda5510..82c1f06 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,8 @@
-# Intel® Integrated Performance Primitives Cryptography
+# Intel® Cryptography Primitives Library
 
 [Build Instructions](./BUILD.md) | [Contributing Guide](#how-to-contribute) | [Documentation](#documentation) | [Get Help](#get-help) | [Intel IPP Product Page](https://www.intel.com/content/www/us/en/developer/tools/oneapi/ipp.html)
 
-Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography) is a secure, fast and lightweight library of building blocks for cryptography, highly-optimized for various Intel® CPUs.
+Intel® Cryptography Primitives Library is a secure, fast and lightweight library of building blocks for cryptography, highly-optimized for various Intel® CPUs.
 
 ## Key Features
 The library provides a comprehensive set of routines commonly used for cryptographic operations, including:
@@ -28,7 +28,7 @@ The library provides a comprehensive set of routines commonly used for cryptogra
 - PRNG/TRNG and Prime Numbers Generation
 - Hash-based signature algorithms
 
-## Reasons to Use Intel IPP Cryptography
+## Reasons to Use Intel® Cryptography Primitives Library
 - Security (constant-time execution for secret processing functions)
 - Designed for the small footprint size
 - Optimized for different Intel CPUs and instruction set architectures (including hardware cryptography instructions support):
@@ -44,21 +44,21 @@ The library provides a comprehensive set of routines commonly used for cryptogra
 
 ## FIPS 140 Compliance
 
-Intel IPP Cryptography supports building blocks (self-tests, services) for FIPS 140-3 compliance.
-See [FIPS] (./README_FIPS.md) document for details.
+Intel® Cryptography Primitives Library supports building blocks (self-tests, services) for FIPS 140-3 compliance.
+See [FIPS](./README_FIPS.md) document for details.
 
 ## Installation
 
-[How to Get and Build the Intel IPP Cryptography Library](./BUILD.md)
+[How to Get and Build the Intel® Cryptography Primitives Library](./BUILD.md)
 
 ## Documentation
 
-- [Introduction to Intel IPP Cryptography Library](./OVERVIEW.md)
+- [Introduction to Intel® Cryptography Primitives Library](./OVERVIEW.md)
 - [Introduction to Crypto Multi-buffer Library](./sources/ippcp/crypto_mb/Readme.md)
-- [Intel IPP Cryptography Build Instructions](./BUILD.md)
-- [Intel IPP Release Notes](https://www.intel.com/content/www/us/en/developer/articles/release-notes/release-notes-for-oneapi-integrated-performance-primitives.html)
-- [Intel IPP Cryptography Developer Reference](https://www.intel.com/content/www/us/en/docs/ipp-crypto/developer-reference/current/overview.html)
-- [Intel IPP Documentation](https://www.intel.com/content/www/us/en/developer/tools/oneapi/ipp-documentation.html)
+- [Intel® Cryptography Primitives Library Build Instructions](./BUILD.md)
+- [Intel® Integrated Performance Primitives Release Notes](https://www.intel.com/content/www/us/en/developer/articles/release-notes/release-notes-for-oneapi-integrated-performance-primitives.html)
+- [Developer Guide and Reference for Intel® Cryptography Primitives Library](https://www.intel.com/content/www/us/en/docs/ipp-crypto/developer-guide-reference/current/overview.htmll)
+- [Intel® Integrated Performance Primitives Documentation](https://www.intel.com/content/www/us/en/developer/tools/oneapi/ipp-documentation.html)
 
 ## Branches Description
 
@@ -71,8 +71,12 @@ Contains code that may not be fully functional and that Intel may substantially 
 See [Contributing](./CONTRIBUTING.md) document for details about contribution process.
 
 ### License
-Intel IPP Cryptography is licensed under Apache License, Version 2.0. By contributing to the project, you agree to the license and copyright terms therein and release your contribution under these terms.
+Intel® Cryptography Primitives Library is licensed under Apache License, Version 2.0. By contributing to the project, you agree to the license and copyright terms therein and release your contribution under these terms.
 
 ## Certification
 
-Intel IPP Cryptography library is not certified for FIPS-140-2 (Security Requirements for Cryptographic Modules) and CMVP (Cryptographic Module Validation Program).
+Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography) 2021.10 release is validated for FIPS-140-3 (Security Requirements for Cryptographic Modules) compliance and has the following CAVP (Cryptographic Algorithm Validation Program) certificates:
+
+- [Intel® Crypto Multi-buffer Library](https://csrc.nist.gov/projects/cryptographic-algorithm-validation-program/details?product=17987)
+- [Intel® Cryptography Primitives Library optimized for Intel® AVX2 ISA](https://csrc.nist.gov/projects/cryptographic-algorithm-validation-program/details?product=17988)
+- [Intel® Cryptography Primitives Library optimized for Intel® AVX512 ISA](https://csrc.nist.gov/projects/cryptographic-algorithm-validation-program/details?product=17989)
diff --git a/README_FIPS.md b/README_FIPS.md
index ca16a29..6c3870a 100644
--- a/README_FIPS.md
+++ b/README_FIPS.md
@@ -1,4 +1,4 @@
-# Intel(R) Integrated Performance Primitives Cryptography (Intel(R) IPP Cryptography) FIPS
+# Intel(R) Cryptography Primitives Library FIPS
 
 ## What is FIPS 140?
 
@@ -23,44 +23,44 @@ In addition, **in recent years FIPS 140 has become a more and more popular requi
 FIPS 140-3 defines 4 security levels (from level 1 - the easiest to level 4 - the most stringent).
 In general, software may be certified at up to level 2.
 
-Intel® Integrated Performance Primitives Cryptography (Intel(R) IPP Cryptography)
+Intel® Cryptography Primitives Library
 provides building blocks of FIPS-mode API (such as self-tests, FIPS-approved
 functionality status query) which can help the end users to fulfill FIPS level 1 requirements.
 Please, refer to [Covered Algorithms](#covered-algorithms) section for the full
 list of FIPS-Approved API which are covered with the selftests.
 
-> NOTE: Intel(R) IPP Cryptography is not **FIPS-Certified** on its own but **FIPS-Compliant**:
-that means Intel(R) IPP Cryptography releases will have Cryptographic Algorithm
+> NOTE: Intel® Cryptography Primitives Library is not **FIPS-Certified** on its own but **FIPS-Compliant**:
+that means Intel® Cryptography Primitives Library releases will have Cryptographic Algorithm
 Validation Program (CAVP) testing and certification done but don't have full
 Cryptographic Module Validation Program certificate as the context of the usage
-of Intel(R) IPP Cryptography's high-performant primitives depends on a more high-level application.
+of Intel® Cryptography Primitives Library's high-performant primitives depends on a more high-level application.
 
-For the results of CAVP testing please contact us via [Intel(R) Community](https://community.intel.com/t5/Intel-Integrated-Performance/bd-p/integrated-performance-primitives).
+For the results of CAVP testing please refer to [Certification](./README.md#Certification) chapter.
 
-Intel(R) IPP Cryptography may be built in FIPS-mode with IPPCP_FIPS_MODE=on
+Intel® Cryptography Primitives Library may be built in FIPS-mode with IPPCP_FIPS_MODE=on
 configuration for ippcp and MBX_FIPS_MODE=on for crypto_MB (see details in [Build section](#build)).
 
-Application, which uses Intel(R) IPP Cryptography may be **FIPS-Certified** by
+Application, which uses Intel® Cryptography Primitives Library may be **FIPS-Certified** by
 matching FIPS 140 requirement and obtaining NIST certificate or also be **FIPS-Compliant** for their own customers.
 
 Please, refer to [Level 1 Specific Requirements](#level-1-specific-requirements)
-for the detailed description of what is done on Intel(R) IPP Cryptography-side
+for the detailed description of what is done on Intel® Cryptography Primitives Library-side
 and what should be done by a more high-level application.
 
 ### Level 1 Specific Requirements
 
 | # | Requirement | Note |
 |---|-------------|------|
-| 1 |Provide service to output module's name / identifier and version to User | Intel(R) IPP Cryptography provides such functionality via ippcpGetLibVersion() API for IPPCP and mbx_getversion() API for crypto_MB |
-| 2 |For every service, output to the user whether it is a FIPS-approved service or not | Intel(R) IPP Cryptography provides such functionality via [ippcp_is_fips_approved_func](#api-for-an-indicator-if-a-function-is-fips-approved) for ippcp and [mbx_is_fips_approved_func](#crypto-multi-buffer-library-api-for-an-indicator-if-a-function-is-fips-approved) for crypto_MB |
+| 1 |Provide service to output module's name / identifier and version to User | Intel® Cryptography Primitives Library provides such functionality via ippcpGetLibVersion() API for IPPCP and mbx_getversion() API for crypto_MB |
+| 2 |For every service, output to the user whether it is a FIPS-approved service or not | Intel® Cryptography Primitives Library provides such functionality via [ippcp_is_fips_approved_func](#api-for-an-indicator-if-a-function-is-fips-approved) for ippcp and [mbx_is_fips_approved_func](#crypto-multi-buffer-library-api-for-an-indicator-if-a-function-is-fips-approved) for crypto_MB |
 | 3 |Zeroize unprotected keys using manual/procedural destruction method | **User's application effort required** |
 | 4 |Run integrity selftest at power on for SW component | **User's application effort required** |
-| 5 | Run known-answer or comparison or fault-detection selftest for individual crypto algorithms before first use | Intel(R) IPP Cryptography provides [fips_selftest_ippcp<algorithm name> API](#covered-algorithms) to run selftests. User's application should call them before the first use of algorithm (see [Example](#example-of-api-usage)) |
-| 6 | Run pairwise consistency selftest for newly generated RSA/ECC keypair | Intel(R) IPP Cryptography provides [fips_selftest_ippcp<algorithm name> API](#covered-algorithms) to run selftests |
-| 7 | Module to guarantee uniqueness of GSM key + IV | **User's application effort required** |
-| 8 | Module to guarantee XTS key1 != key2 | Intel(R) IPP Cryptography-side check |
+| 5 | Run known-answer or comparison or fault-detection selftest for individual crypto algorithms before first use | Intel® Cryptography Primitives Library provides [fips_selftest_ippcp<algorithm name> API](#covered-algorithms) to run selftests. User's application should call them before the first use of algorithm (see [Example](#example-of-api-usage)) |
+| 6 | Run pairwise consistency selftest for newly generated RSA/ECC keypair | Intel® Cryptography Primitives Library provides [fips_selftest_ippcp<algorithm name> API](#covered-algorithms) to run selftests |
+| 7 | Module to guarantee uniqueness of GCM key + IV | **User's application effort required** |
+| 8 | Module to guarantee XTS key1 != key2 | Intel® Cryptography Primitives Library-side check |
 | 9 | (non-production) Extract raw noise source output samples of RBG for quality analysis | DBRNG is currently out of the cryptography boundary |
-| 10| (non-production) Run crypto algorithm testing with NIST-generated vectors | Done offline by Intel(R) IPP Cryptography for the [covered algorithms](#covered-algorithms) |
+| 10| (non-production) Run crypto algorithm testing with NIST-generated vectors | Done offline by Intel® Cryptography Primitives Library for the [covered algorithms](#covered-algorithms) |
 
 For the implementation details about the steps in [Level 1 Specific Requirements](#level-1-specific-requirements)
 specified as **User's application effort required** please refer to the
@@ -68,11 +68,11 @@ specified as **User's application effort required** please refer to the
 
 ## Cryptographic boundary
 
-### Intel(R) IPP Cryptography Structure Diagram
+### Intel® Cryptography Primitives Library Structure Diagram
 
-![Intel(R) IPP Cryptography Architecture](./data/images/README_FIPS-pictures-0-ippcp_architecture.png)
+![Intel® Cryptography Primitives Library Architecture](./data/images/README_FIPS-pictures-0-ippcp_architecture.png)
 
-1. Intel(R) IPP Cryptography Library uses special structures (Spec and States)
+1. Intel® Cryptography Primitives Library uses special structures (Spec and States)
 to store context information and provides service functions to work with context (e.g. Initialization).
 
 > Note: Application responsible for the life-cycle of context. All memory allocations
@@ -82,7 +82,7 @@ and sanitizing happens on application side (including #3 in [Level 1 Specific Re
 3. FIPS Self-tests API and service to query if algorithm is FIPS-Compliant
 (API for #2, #5, #6 in [Level 1 Specific Requirements](#level-1-specific-requirements)).
 4. Version information (API for #1 in [Level 1 Specific Requirements](#level-1-specific-requirements)), Dispatcher control.
-5. Intel(R) IPP Cryptography chooses the optimal code path depending on
+5. Intel® Cryptography Primitives Library chooses the optimal code path depending on
 hardware features and application settings (via Dispatcher control API).
 6. The algorithms may have multiple code branches for different hardware
 architecture and different compilation flags may be used to achieve better performance.
@@ -91,10 +91,10 @@ Refer to [Covered Algorithms](#covered-algorithms) section to check which
 algorithms are within the cryptographic boundary.
 
 > Note: For #10 in [Level 1 Specific Requirements](#level-1-specific-requirements)
-Intel(R) IPP Cryptography tests all code-paths and algorithms modes as
+Intel® Cryptography Primitives Library tests all code-paths and algorithms modes as
 the implementation may vary depending on the target hardware.
 
-## Intel(R) IPP Cryptography Usage in the FIPS-mode
+## Intel® Cryptography Primitives Library Usage in the FIPS-mode
 
 ### Build
 
@@ -103,9 +103,9 @@ CMake flag -DIPPCP_FIPS_MODE:BOOL=on should be used to build ippcp library and
 self-tests and FIPS-support query (see [covered algorithms](#covered-algorithms) for the details).
 Selftests can be build in two modes - with internal memory allocation or without it.
 
-Configuration example for ippcp with Intel® C++ Compiler:
+Configuration example for ippcp with Intel® oneAPI DPC++/C++ Compiler:
 
-`CC=icc CXX=icpc cmake CMakeLists.txt -B_build -DARCH=intel64 -DIPPCP_FIPS_MODE:BOOL=on[-DIPPCP_SELFTEST_USE_MALLOC:BOOL=on]`
+`CC=icx CXX=icpx cmake CMakeLists.txt -B_build -DARCH=intel64 -DIPPCP_FIPS_MODE:BOOL=on [-DIPPCP_SELFTEST_USE_MALLOC:BOOL=on]`
 
 > Note: selftests with internal memory allocation uses malloc, which introduces
 a c runtime dependency.
@@ -118,7 +118,7 @@ Configuration example for crypto_MB with GCC:
 
 ### Example of API Usage
 
-#### Intel(R) IPP Cryptography Example
+#### Intel® Cryptography Primitives Library Example
 
 ```cpp
 
@@ -132,7 +132,7 @@ if(!ippcp_is_fips_approved_func(AESEncryptCBC)) {
 // 2. Run the Selftest
 fips_test_status selftest_status = IPPCP_ALGO_SELFTEST_OK;
 
-// Query buffer size for the test and allocate it (it can be done on Intel(R) IPP Cryptography side with IPPCP_SELFTEST_USE_MALLOC=on)
+// Query buffer size for the test and allocate it (it can be done on Intel® Cryptography Primitives Library side with IPPCP_SELFTEST_USE_MALLOC=on)
 int BuffSize = 0;
 selftest_status += fips_selftest_ippsAESEncryptDecrypt_get_size(&BuffSize);
 std::vector<Ipp8u> pBuff(BuffSize);
@@ -147,7 +147,7 @@ if (IPPCP_ALGO_SELFTEST_OK != selftest_status) {
 
 //------ FIPS-required part ends (only needed before the first use of algorithm)
 
-//------ Common Intel(R) IPP Cryptography usage
+//------ Common Intel® Cryptography Primitives Library usage
 // ...
 IppStatus status = ippsAESEncryptCBC(plain, cipher, block_size, pAES, cipherV);
 // ...
@@ -183,10 +183,10 @@ mbx_nistp256_ecdh_mb8(sharedBA, prvB, pubAx, pubAy, pubAz_curr, 0);
 
 ### Covered Algorithms
 
-#### Intel(R) IPP Cryptography
+#### Intel® Cryptography Primitives Library
 
 Each API from the list is covered with the selftest fips_selftest_ipps<API_name>
-available in Intel(R) IPP Cryptography build in FIPS mode.
+available in Intel® Cryptography Primitives Library build in FIPS mode.
 
 ##### AES
 
@@ -316,6 +316,15 @@ fips_test_status fips_selftest_ippsGFpECSharedSecretDH (Ipp8u *pGFpBuff Ipp8u *p
 valid buffer for selftest of size indicated by `fips_selftest_ippsGFpECSignVerifyDSA_get_size_GFpEC_buff`
 and `pDataBuff` is the valid buffer for selftest of size indicated by `fips_selftest_ippsGFpECSignVerifyDSA_get_size_data_buff`.
 
+##### LMS verify
+
+```cpp
+fips_test_status fips_selftest_ippsLMSVerify_get_size (int *pBuffSize);
+fips_test_status fips_selftest_ippsLMSVerify (Ipp8u *pBuffer);
+```
+
+, where `pBuffer` is the valid buffer for selftest of size indicated by `fips_selftest_ippsLMSVerify_get_size`.
+
 ##### API for an indicator if a function is FIPS-approved
 
 ```cpp
diff --git a/THIRD-PARTY-PROGRAMS.txt b/THIRD-PARTY-PROGRAMS.txt
index ba4c3b5..d84bd6c 100644
--- a/THIRD-PARTY-PROGRAMS.txt
+++ b/THIRD-PARTY-PROGRAMS.txt
@@ -1,4 +1,4 @@
-Intel(R) Integrated Performance Primitives Cryptography Third Party Programs File
+Intel(R) Cryptography Primitives Library Third Party Programs File
 
 This file contains the list of third party software (“third party programs”) contained in the Intel software and their required notices and/or license terms.
 This third party software, even if included with the distribution of the Intel software, may be governed by separate license terms, including without limitation, third party license terms, other Intel software license terms, and open source software license terms.
diff --git a/debian/changelog b/debian/changelog
index 4cc1686..10326db 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,15 @@
+ipp-crypto (1:1.0.0-0ubuntu1) plucky; urgency=medium
+
+  * d/changelog : add epoch to version since upstream uses now
+      semantic versioning
+  * d/control : update package names for ipcrypto-mb and libippcp
+  * d/control : change upstream vcs and description
+  * d/p : refresh patch
+  * New upstream version 1.0.0
+  * d/watch : upstream repo renaming and versioning scheme change
+
+ -- Hector Cao <[e-mail]>  Mon, 25 Nov 2024 12:45:16 +0100
+
 ipp-crypto (2021.12.1-0ubuntu1) oracular; urgency=medium
 
   * New upstream release (LP: #2075496).
diff --git a/debian/control b/debian/control
index 9f0a92a..bcdc780 100644
--- a/debian/control
+++ b/debian/control
@@ -12,15 +12,15 @@ Build-Depends: debhelper-compat (=13),
                nasm,
                libssl-dev
 Standards-Version: 4.6.2
-Homepage: https://github.com/intel/ipp-crypto
+Homepage: https://github.com/intel/cryptography-primitives
 
-Package: libippcp11
+Package: libippcp12
 Section: libs
 Architecture: amd64
 Depends: ${shlibs:Depends}, ${misc:Depends}
 Pre-Depends: ${misc:Pre-Depends}
-Description: Intel® Integrated Performance Primitives Cryptography
- Intel® Integrated Performance Primitives (Intel® IPP) Cryptography is a
+Description: Intel® Cryptography Primitives Library
+ Intel® Cryptography Primitives Library (Intel® IPP) Cryptography is a
  secure, fast and lightweight library of building blocks for cryptography,
  highly-optimized for various Intel® CPUs.
  .
@@ -37,20 +37,20 @@ Description: Intel® Integrated Performance Primitives Cryptography
 Package: libippcp-dev
 Section: libdevel
 Architecture: amd64
-Depends: ${misc:Depends}, libippcp11 (= ${binary:Version})
+Depends: ${misc:Depends}, libippcp12 (= ${binary:Version})
 Pre-Depends: ${misc:Pre-Depends}
-Description: Intel® Integrated Performance Primitives Cryptography development files
- Intel® Integrated Performance Primitives (Intel® IPP) Cryptography is a
+Description: Intel® Cryptography Primitives Library development files
+ Intel® Cryptography Primitives Library (Intel® IPP) Cryptography is a
  secure, fast and lightweight library of building blocks for cryptography,
  highly-optimized for various Intel® CPUs.
  This package contains the development libraries and headers.
 
-Package: libcrypto-mb11
+Package: libcrypto-mb12
 Section: libs
 Architecture: amd64
 Depends: ${shlibs:Depends}, ${misc:Depends}
 Pre-Depends: ${misc:Pre-Depends}
-Description: Intel® Integrated Performance Primitives Cryptography Multi-buffer
+Description: Intel® Cryptography Primitives Library Multi-buffer
  Some of the cryptography algorithms cannot be parallelized due to
  their specificity (eg the RSA algorithm).
  The way to get high-performance implementations of such cryptographic
@@ -70,7 +70,7 @@ Description: Intel® Integrated Performance Primitives Cryptography Multi-buffer
 Package: libcrypto-mb-dev
 Section: libdevel
 Architecture: amd64
-Depends: ${misc:Depends}, libcrypto-mb11 (= ${binary:Version})
+Depends: ${misc:Depends}, libcrypto-mb12 (= ${binary:Version})
 Pre-Depends: ${misc:Pre-Depends}
 Description: Intel® IPP Cryptography Multi-buffer development files
  This package contains the development libraries and headers.
diff --git a/debian/libcrypto-mb11.install b/debian/libcrypto-mb12.install
similarity index 100%
rename from debian/libcrypto-mb11.install
rename to debian/libcrypto-mb12.install
diff --git a/debian/libippcp11.install b/debian/libippcp12.install
similarity index 100%
rename from debian/libippcp11.install
rename to debian/libippcp12.install
diff --git a/debian/patches/0001-Undefine-FORTIFY_SOURCE-before-define.patch b/debian/patches/0001-Undefine-FORTIFY_SOURCE-before-define.patch
index 5784def..6f6bc6d 100644
--- a/debian/patches/0001-Undefine-FORTIFY_SOURCE-before-define.patch
+++ b/debian/patches/0001-Undefine-FORTIFY_SOURCE-before-define.patch
@@ -1,6 +1,6 @@
-From bb1d2b75834f9e89457aa4ae08552e6fa870375c Mon Sep 17 00:00:00 2001
+From 1018ebdc0543702edbedb81c57d432c46955a9da Mon Sep 17 00:00:00 2001
 From: Hector Cao <[e-mail]>
-Date: Tue, 20 Feb 2024 14:45:02 +0000
+Date: Mon, 4 Nov 2024 01:06:29 +0100
 Subject: [PATCH] Undefine FORTIFY_SOURCE before define
 
 Some toolchains have FORTIFY_SOURCE defined and wlil raise warning
@@ -14,44 +14,44 @@ So, undefine FORTIFY_SOURCE before defining it to get rid of this
  3 files changed, 3 insertions(+), 3 deletions(-)
 
 diff --git a/sources/cmake/linux/GNU8.2.0.cmake b/sources/cmake/linux/GNU8.2.0.cmake
-index 96658a8..1d08d80 100644
+index 55e60ae..5a4e431 100644
 --- a/sources/cmake/linux/GNU8.2.0.cmake
 +++ b/sources/cmake/linux/GNU8.2.0.cmake
-@@ -74,7 +74,7 @@ if ((${ARCH} MATCHES "ia32") OR (NOT NONPIC_LIB))
- endif()
- 
+@@ -95,7 +95,7 @@ endif(${ARCH} MATCHES "ia32")
+ # Optimization level = 3, no-debug definition (turns off asserts), warnings=errors
+ set(CMAKE_C_FLAGS_RELEASE " -O3 -DNDEBUG -Werror")
  # Security flag that adds compile-time and run-time checks
--set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_FORTIFY_SOURCE=2")
-+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2")
+-set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -D_FORTIFY_SOURCE=2")
++set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2")
  
- if(NOT NONPIC_LIB)
-   # Position Independent Execution (PIE)
+ set(w7_opt "${w7_opt} -march=pentium4 -msse2")
+ set(s8_opt "${s8_opt} -march=core2 -mssse3")
 diff --git a/sources/ippcp/CMakeLists.txt b/sources/ippcp/CMakeLists.txt
-index 516fc1e..e01ab0b 100644
+index 1864c1a..18f8358 100644
 --- a/sources/ippcp/CMakeLists.txt
 +++ b/sources/ippcp/CMakeLists.txt
-@@ -538,7 +538,7 @@ if(MERGED_BLD)
-     if(${ARCH} MATCHES "ia32")
-       set_source_files_properties(${DISPATCHER_C_SOURCES} PROPERTIES COMPILE_FLAGS "${CC_FLAGS_INLINE_ASM_UNIX_IA32} -D_GNU_SOURCE -D_FORTIFY_SOURCE=2 -O2")
-     else()
--      set_source_files_properties(${DISPATCHER_C_SOURCES} PROPERTIES COMPILE_FLAGS "${CC_FLAGS_INLINE_ASM_UNIX_INTEL64} -D_GNU_SOURCE -D_FORTIFY_SOURCE=2 -O2")
-+      set_source_files_properties(${DISPATCHER_C_SOURCES} PROPERTIES COMPILE_FLAGS "${CC_FLAGS_INLINE_ASM_UNIX_INTEL64} -D_GNU_SOURCE -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -O2")
+@@ -560,7 +560,7 @@ if(MERGED_BLD)
+   if(UNIX)
+     set(DISPATCHER_C_SOURCES_COMPILE_FLAGS "-D_GNU_SOURCE -O2")
+     if(CMAKE_BUILD_TYPE STREQUAL "Release")
+-      set(DISPATCHER_C_SOURCES_COMPILE_FLAGS "${DISPATCHER_C_SOURCES_COMPILE_FLAGS} -D_FORTIFY_SOURCE=2")
++      set(DISPATCHER_C_SOURCES_COMPILE_FLAGS "${DISPATCHER_C_SOURCES_COMPILE_FLAGS} -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2")
      endif()
-   endif()
  
+     if(${ARCH} MATCHES "ia32")
 diff --git a/sources/ippcp/crypto_mb/src/cmake/linux/GNU.cmake b/sources/ippcp/crypto_mb/src/cmake/linux/GNU.cmake
-index 327652d..1756da0 100644
+index e88ddf5..a4e8d65 100644
 --- a/sources/ippcp/crypto_mb/src/cmake/linux/GNU.cmake
 +++ b/sources/ippcp/crypto_mb/src/cmake/linux/GNU.cmake
-@@ -31,7 +31,7 @@ set(CMAKE_C_FLAGS_SECURITY "${CMAKE_C_FLAGS_SECURITY} -Wformat -Wformat-security
- if(${CMAKE_BUILD_TYPE} STREQUAL "Release")
-     if(NOT DEFINED NO_FORTIFY_SOURCE)
-         # Security flag that adds compile-time and run-time checks. 
--        set(CMAKE_C_FLAGS_SECURITY "${CMAKE_C_FLAGS_SECURITY} -D_FORTIFY_SOURCE=2")
-+        set(CMAKE_C_FLAGS_SECURITY "${CMAKE_C_FLAGS_SECURITY} -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2")
-     endif()
+@@ -70,7 +70,7 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-pointer-to-int-cast")
+ set(CMAKE_C_FLAGS_RELEASE " -O3 -DNDEBUG")
+ if(NOT DEFINED NO_FORTIFY_SOURCE)
+   # Security flag that adds compile-time and run-time checks
+-  set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -D_FORTIFY_SOURCE=2")
++  set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2")
  endif()
  
+ set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
 -- 
-2.40.1
+2.43.0
 
diff --git a/debian/watch b/debian/watch
index 6083681..1bbe8a6 100644
--- a/debian/watch
+++ b/debian/watch
@@ -1,4 +1,4 @@
 version=4
-opts="filenamemangle=s%(?:.*?)ippcp_(\d[\d.][\d.]*)\.tar\.gz%@PACKAGE@-$1.tar.gz%" \
-             https://github.com/intel/ipp-crypto/tags \
-             (?:.*?/)?ippcp_?(\d[\d.][\d.]*)\.tar\.gz debian uupdate
+opts="filenamemangle=s%(?:.*?)v(\d[\d.][\d.]*)\.tar\.gz%@PACKAGE@-$1.tar.gz%" \
+             https://github.com/intel/cryptography-primitives/tags \
+             (?:.*?/)?v(\d[\d.][\d.]*)\.tar\.gz debian uupdate
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index adeccbc..4e20d35 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography) examples
+# Intel® Cryptography Primitives Library examples
 #
 
 # List of examples for targets generation
@@ -38,6 +38,12 @@ set(IPPCP_EXAMPLES
   # SMS4 examples
   sms4/sms4-128-cbc-encryption.cpp
   sms4/sms4-128-cbc-decryption.cpp
+  # Hash examples
+  hash/sm3_hash_rmf.cpp
+  # Post-quantum algorithms examples
+  post-quantum/lms_m32_h5_w8_verification.cpp
+  # Elliptic curve algorithms examples
+  ecdsa/ecdsa-256r1-sign.cpp 
   )
 
 cmake_policy(SET CMP0003 NEW)
@@ -85,7 +91,7 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_LIST_DIR)
 # Build with standalone library
   cmake_minimum_required(VERSION 3.1)
 
-  project("Intel IPP Cryptography Examples" CXX)
+  project("Intel Cryptography Primitives Library Examples" CXX)
   set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "" FORCE)
 
   option(BUILD_EXAMPLES "Build examples" ON)
@@ -94,7 +100,7 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_LIST_DIR)
   find_package(IPPCrypto REQUIRED MODULE)
 
   if (NOT IPPCRYPTO_FOUND)
-    message(FATAL_ERROR "No Intel IPP Cryptography library found on the system. To build examples with pre-built library, please specify -DIPPCRYPTO_ROOT_DIR=<path> option, where <path> is the path to directory that contains include/ and lib/ folders of Intel IPP Cryptography product.")
+    message(FATAL_ERROR "No Intel Cryptography Primitives Library found on the system. To build examples with pre-built library, please specify -DIPPCRYPTO_ROOT_DIR=<path> option, where <path> is the path to directory that contains include/ and lib/ folders of Intel Cryptography Primitives Library product.")
   endif()
 
   # Define library to link
@@ -108,7 +114,7 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_LIST_DIR)
 else()
 # Build with library sources
   if(NOT BUILD_EXAMPLES OR NOT MERGED_BLD)
-    message(FATAL_ERROR "Only merged library build is currently supported for Intel IPP Cryptography examples. Use -DMERGED_BLD:BOOL=on options.")
+    message(FATAL_ERROR "Only merged library build is currently supported for Intel Cryptography Primitives Library examples. Use -DMERGED_BLD:BOOL=on options.")
   endif()
 endif()
 
diff --git a/examples/FindIPPCrypto.cmake b/examples/FindIPPCrypto.cmake
index 454fb47..c8b35f4 100644
--- a/examples/FindIPPCrypto.cmake
+++ b/examples/FindIPPCrypto.cmake
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 # library detection routine.
 #
 # If found the following variables will be available:
@@ -29,11 +29,11 @@ include(FindPackageHandleStandardArgs)
 
 macro(ippcp_not_found)
   set(IPPCRYPTO_FOUND OFF)
-  set(IPPCRYPTO_ROOT_DIR "${IPPCRYPTO_ROOT_DIR}" CACHE PATH "Path to Intel IPP Cryptography root directory")
+  set(IPPCRYPTO_ROOT_DIR "${IPPCRYPTO_ROOT_DIR}" CACHE PATH "Path to Intel Cryptography Primitives Library root directory")
   return()
 endmacro()
 
-# Try to find Intel IPP Cryptography library on the system if root dir is not defined externally
+# Try to find Intel Cryptography Primitives Library on the system if root dir is not defined externally
 if (NOT IPPCRYPTO_ROOT_DIR OR NOT EXISTS "${IPPCRYPTO_ROOT_DIR}/include/ippcp.h")
   set(ippcp_search_paths
     ${CMAKE_CURRENT_SOURCE_DIR}/../.build
@@ -56,7 +56,7 @@ if (NOT IPPCRYPTO_ROOT_DIR OR NOT EXISTS "${IPPCRYPTO_ROOT_DIR}/include/ippcp.h"
   find_path(IPPCRYPTO_ROOT_DIR include/ippcp.h PATHS ${ippcp_search_paths})
 endif()
 
-set(IPPCRYPTO_INCLUDE_DIRS "${IPPCRYPTO_ROOT_DIR}/include" CACHE PATH "Path to Intel IPP Cryptography library include directory" FORCE)
+set(IPPCRYPTO_INCLUDE_DIRS "${IPPCRYPTO_ROOT_DIR}/include" CACHE PATH "Path to Intel Cryptography Primitives Library include directory" FORCE)
 
 # Check found directory
 if(NOT IPPCRYPTO_ROOT_DIR
@@ -107,9 +107,9 @@ endforeach()
 
 list(REMOVE_DUPLICATES IPPCRYPTO_LIBRARIES)
 
-message(STATUS "Found Intel IPP Cryptography at: ${IPPCRYPTO_ROOT_DIR}")
+message(STATUS "Found Intel Cryptography Primitives Library at: ${IPPCRYPTO_ROOT_DIR}")
 
 set(IPPCRYPTO_FOUND ON)
-set(IPPCRYPTO_ROOT_DIR "${IPPCRYPTO_ROOT_DIR}" CACHE PATH "Path to Intel IPP Cryptography root directory")
-set(IPPCRYPTO_INCLUDE_DIRS "${IPPCRYPTO_INCLUDE_DIRS}" CACHE PATH "Path to Intel IPP Cryptography include directory")
-set(IPPCRYPTO_LIBRARIES "${IPPCRYPTO_LIBRARIES}" CACHE STRING "Intel IPP Cryptography libraries")
+set(IPPCRYPTO_ROOT_DIR "${IPPCRYPTO_ROOT_DIR}" CACHE PATH "Path to Intel Cryptography Primitives Library root directory")
+set(IPPCRYPTO_INCLUDE_DIRS "${IPPCRYPTO_INCLUDE_DIRS}" CACHE PATH "Path to Intel Cryptography Primitives Library include directory")
+set(IPPCRYPTO_LIBRARIES "${IPPCRYPTO_LIBRARIES}" CACHE STRING "Intel Cryptography Primitives Library libraries")
diff --git a/examples/README.md b/examples/README.md
index 445eb45..422be2d 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -1,4 +1,4 @@
-# Building usage examples of Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography) library
+# Building usage examples of Intel® Cryptography Primitives Library
 
 ## System requirements
 
@@ -20,9 +20,9 @@ Only merged library (cmake option `-DMERGED_BLD:BOOL=ON`) builds are supported f
    `cmake CMakeLists.txt -B_build -G<vs_generator> [-T"Intel® C++ Compiler <version>"] -DBUILD_EXAMPLES:BOOL=ON`
 
    For the Visual Studio\* generators options, please refer to the CMake help.
-   The toolchain switch is optional, specify it if you want to build the library and examples using Intel® C++ Compiler.
+   The toolchain switch is optional, specify it if you want to build the library and examples using Intel® oneAPI DPC++/C++ Compiler.
 
-   For the list of supported compiler versions or other cmake build options, please refer to the library root README.md file.
+   For the list of supported compiler versions or other cmake build options, please refer to the library root [BUILD.md](../BUILD.md) file.
 
 2. On Linux\*/macOS\*, build with `make -j8 <target>`. You can use the following targets:
 
@@ -50,17 +50,17 @@ Only merged library (cmake option `-DMERGED_BLD:BOOL=ON`) builds are supported f
    `cmake CMakeLists.txt -B_build`
 
    On Windows\* OS it is required to specify a generator (`-G` option) and optionally a toolchain (`-T` option)
-   to build with Intel® C++ Compiler. Example:
+   to build with Intel® oneAPI DPC++/C++ Compiler. Example:
 
    `cmake CMakeLists.txt -B_build -G<vs_generator> [-T"Intel C++ Compiler <version>"]`
 
    For the Visual Studio\* generators options, please refer to the CMake help.
 
-2. The build system will scan the system for the Intel IPP Cryptography library.
+2. The build system will scan the system for the Intel® Cryptography Primitives Library.
    If it is found, you’ll see the following message:
 
    ```
-   -- Found Intel IPP Cryptography at: /home/user/intel/ippcp
+   -- Found Intel® Cryptography Primitives Library at: /home/user/intel/ippcp
    -- Configuring done
    ```
 
@@ -70,7 +70,7 @@ Only merged library (cmake option `-DMERGED_BLD:BOOL=ON`) builds are supported f
 3. Run the build process as described in the [Build with library sources](#build-with-library-sources).
 
 
-# How to add a new example into Intel IPP Cryptography library:
+# How to add a new example into Intel® Cryptography Primitives Library:
 
 1. Choose a category (a folder), where to put the example, and a filename. Use
    existing folders where applicable.
@@ -89,7 +89,7 @@ Only merged library (cmake option `-DMERGED_BLD:BOOL=ON`) builds are supported f
 4. Add the example to the build: open *examples/CMakeLists.txt* file and add the
    new file to the *IPPCP_EXAMPLES* list.
 
-5. Make sure it can be built using Intel IPP Cryptography examples build procedure, and it
+5. Make sure it can be built using Intel® Cryptography Primitives Library examples build procedure, and it
    works correctly.
 
 You are ready to submit a pull request!
diff --git a/examples/ecdsa/categoryOptions.cmake b/examples/ecdsa/categoryOptions.cmake
new file mode 100644
index 0000000..70c7535
--- /dev/null
+++ b/examples/ecdsa/categoryOptions.cmake
@@ -0,0 +1,20 @@
+#=========================================================================
+# Copyright (C) 2024 Intel Corporation
+#
+# Licensed under the Apache License,  Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law  or agreed  to  in  writing,  software
+# distributed under  the License  is  distributed  on  an  "AS IS"  BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the  specific  language  governing  permissions  and
+# limitations under the License.
+#=========================================================================
+
+set(ecdsa_CATEGORY_COMMON_SOURCES
+    ${CMAKE_CURRENT_SOURCE_DIR}/utils/bignum.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/utils/utils.cpp
+   )
diff --git a/examples/ecdsa/ecdsa-256r1-sign.cpp b/examples/ecdsa/ecdsa-256r1-sign.cpp
new file mode 100644
index 0000000..ab78686
--- /dev/null
+++ b/examples/ecdsa/ecdsa-256r1-sign.cpp
@@ -0,0 +1,141 @@
+/*************************************************************************
+* Copyright (C) 2024 Intel Corporation
+*
+* Licensed under the Apache License,  Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* 	http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law  or agreed  to  in  writing,  software
+* distributed under  the License  is  distributed  on  an  "AS IS"  BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the  specific  language  governing  permissions  and
+* limitations under the License.
+*************************************************************************/
+
+// /*!
+//   *
+//   *  \file
+//   *
+//   *  \brief ECDSA signature example
+//   *
+//   *  This example showcases the utilization of the elliptic curve
+//   *  digital signature algorithm(ECDSA) over NIST P-256 curve with
+//   *  DSA scheme for signature generation.
+//   *
+//   */
+
+#include <string.h>
+#include <memory>
+
+#include <vector>
+
+#include "ippcp.h"
+#include "bignum.h"
+#include "utils.h"
+#include "examples_common.h"
+
+/* Message digest */
+static const Ipp8u msg_digest[] = { 0x56,0xec,0x33,0xa1,0xa6,0xe7,0xc4,0xdb,0x77,0x03,0x90,0x1a,0xfb,0x2e,0x1e,0x4e,
+                                    0x50,0x09,0xfe,0x04,0x72,0x89,0xc5,0xc2,0x42,0x13,0x6c,0xe3,0xb7,0xf6,0xac,0x44 };
+
+/* Regular and ephemeral private keys */
+static const Ipp8u d[]          = { 0x64,0xb4,0x72,0xda,0x6d,0xa5,0x54,0xca,0xac,0x3e,0x4e,0x0b,0x13,0xc8,0x44,0x5b,
+                                    0x1a,0x77,0xf4,0x59,0xee,0xa8,0x4f,0x1f,0x58,0x8b,0x5f,0x71,0x3d,0x42,0x9b,0x51 };
+static const Ipp8u k[]          = { 0xde,0x68,0x2a,0x64,0x87,0x07,0x67,0xb9,0x33,0x5d,0x4f,0x82,0x47,0x62,0x4a,0x3b,
+                                    0x7f,0x3c,0xe9,0xf9,0x45,0xf2,0x80,0xa2,0x61,0x6a,0x90,0x4b,0xb1,0xbb,0xa1,0x94 };
+
+/* signature */
+static const Ipp8u r[]          = { 0xac,0xc2,0xc8,0x79,0x6f,0x5e,0xbb,0xca,0x7a,0x5a,0x55,0x6a,0x1f,0x6b,0xfd,0x2a,
+                                    0xed,0x27,0x95,0x62,0xd6,0xe3,0x43,0x88,0x5b,0x79,0x14,0xb5,0x61,0x80,0xac,0xf3 };
+static const Ipp8u s[]          = { 0x03,0x89,0x05,0xcc,0x2a,0xda,0xcd,0x3c,0x5a,0x17,0x6f,0xe9,0x18,0xb2,0x97,0xef,
+                                    0x1c,0x37,0xf7,0x2b,0x26,0x76,0x6c,0x78,0xb2,0xa6,0x05,0xca,0x19,0x78,0xf7,0x8b };
+
+static const unsigned int primeBitSize = 256;
+
+static const unsigned int ordWordSize   = 8;
+static const unsigned int msgWordSize   = 8;
+static const unsigned int primeWordSize = 8;
+
+/*! Main function */
+int main(void)
+{
+    /* Internal function status */
+    IppStatus status = ippStsNoErr;
+
+    /* Size of the context of a GF field. It will be set up in ippsGFpGetSize() */
+    int GFpBuffSize = 0;
+
+    /* Size of the context of an elliptic curve field. It will be set up in ippsGFpECGetSize() */
+    int GFpECBuffSize = 0;
+
+    /* Size of the scratch buffer */
+    int scratchSize = 0;
+
+    /* Create integers R and S for the digital signature */
+    BigNumber bnR(NULL, ordWordSize, ippBigNumPOS);
+    BigNumber bnS(NULL, ordWordSize, ippBigNumPOS);
+
+    /* Initialize message digest to be digitally signed i.e. encrypted with a private key */
+    BigNumber bnMsgDigest((const Ipp32u *)msg_digest, msgWordSize, ippBigNumPOS);
+    
+    /* Initialize regular and ephemeral private keys of the signer */
+    BigNumber bnRegPrivate((const Ipp32u *)d, primeWordSize, ippBigNumPOS);
+    BigNumber bnEphPrivate((const Ipp32u *)k, primeWordSize, ippBigNumPOS);
+
+    /* Initialize known digital signatures */
+    BigNumber bnRref((const Ipp32u *)r, ordWordSize, ippBigNumPOS);
+    BigNumber bnSref((const Ipp32u *)s, ordWordSize, ippBigNumPOS);
+
+    /* 1. Get the size of the context of a GF field */
+    status = ippsGFpGetSize(primeBitSize, &GFpBuffSize);
+    if (!checkStatus("ippsGFpGetSize", ippStsNoErr, status))
+        return status;
+
+    /* 2. Allocate memory for the GF field context */
+    std::vector<Ipp8u> pGFpBuff(GFpBuffSize);
+    IppsGFpState *pGF = (IppsGFpState *)(pGFpBuff.data());
+
+    /* 3. Initialize the context of a prime finite field GF */
+    status = ippsGFpInitFixed(primeBitSize, ippsGFpMethod_p256r1(), pGF);
+    if (!checkStatus("ippsGFpInitFixed", ippStsNoErr, status))
+        return status;
+
+    /* 4. Get the size of an elliptic curve over the finite field */
+    status = ippsGFpECGetSize(pGF, &GFpECBuffSize);
+    if (!checkStatus("ippsGFpECGetSize", ippStsNoErr, status))
+        return status;
+
+    /* 5. Allocate memory for elliptic curve cryptosystem */
+    std::vector<Ipp8u> pGFpECBuff(GFpECBuffSize);
+    IppsGFpECState *pEC = (IppsGFpECState *)(pGFpECBuff.data());
+
+    /* 6. Initialize the context for the cryptosystem based on a standard elliptic curve */
+    status = ippsGFpECInitStd256r1(pGF, pEC);
+    if (!checkStatus("ippsGFpECInitStd256r1", ippStsNoErr, status))
+        return status;
+
+    /* 7. Get the size of the scratch buffer */
+    status = ippsGFpECScratchBufferSize(2, pEC, &scratchSize);
+    if (!checkStatus("ippsGFpECScratchBufferSize", ippStsNoErr, status))
+        return status;
+
+    /* 8. Allocate memory for the scratch buffer */
+    std::vector<Ipp8u> pScratchBuffer(scratchSize);
+
+    /* 9. Compute the digital signature over the message digest */
+    status = ippsGFpECSignDSA(bnMsgDigest, bnRegPrivate, bnEphPrivate,
+                              bnR, bnS, pEC, pScratchBuffer.data());
+    if (!checkStatus("ippsGFpECSignDSA", ippStsNoErr, status))
+        return status;
+
+    bool sigFlagErr;
+    /* 10. Validate the generated digest by comparing it to the known one */
+    sigFlagErr = (bnR == bnRref);
+    sigFlagErr &= (bnS == bnSref);
+
+    PRINT_EXAMPLE_STATUS("ippsGFpECSignDSA", "ECDSA signature", sigFlagErr)
+
+    return status;
+}
diff --git a/examples/examplesBuildOptions.cmake b/examples/examplesBuildOptions.cmake
index e3d830a..83e6c19 100644
--- a/examples/examplesBuildOptions.cmake
+++ b/examples/examplesBuildOptions.cmake
@@ -39,7 +39,7 @@ if(WIN32)
 
   set(LINK_FLAG_S_ST_WINDOWS "/nologo /NODEFAULTLIB /VERBOSE:SAFESEH /INCREMENTAL:NO /NXCOMPAT /DYNAMICBASE /SUBSYSTEM:CONSOLE")
 
-  ippcp_extend_variable(CMAKE_CXX_FLAGS "/TP /nologo /W3 /EHa /Zm512 /GS")
+  ippcp_extend_variable(CMAKE_CXX_FLAGS "/nologo /W3 /EHa /Zm512 /GS")
   # Intel compiler-specific option
   if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Intel" OR ${CMAKE_CXX_COMPILER_ID} STREQUAL "IntelLLVM")
     ippcp_extend_variable(CMAKE_CXX_FLAGS "-nologo -Qfp-speculation:safe -Qfreestanding")
@@ -65,7 +65,8 @@ if(UNIX)
       ippcp_extend_variable(LINK_FLAG_S_ST_LINUX "-no-pie")
     endif()
 
-    ippcp_extend_variable(CMAKE_CXX_FLAGS "-D_FORTIFY_SOURCE=2 -Wformat -Wformat-security")
+    ippcp_extend_variable(CMAKE_CXX_FLAGS "-Wformat -Wformat-security")
+    ippcp_extend_variable(CMAKE_CXX_FLAGS_RELEASE "-D_FORTIFY_SOURCE=2")
 
     if(${ARCH} MATCHES "ia32")
       ippcp_extend_variable(LINK_FLAG_S_ST_LINUX "-m32")
@@ -110,4 +111,4 @@ macro(ippcp_example_set_build_options target link_libraries)
       target_link_libraries(${target} ipgo)
     endif()
   endif()
-endmacro()
\ No newline at end of file
+endmacro()
diff --git a/examples/hash/sm3_hash_rmf.cpp b/examples/hash/sm3_hash_rmf.cpp
new file mode 100644
index 0000000..5dfb7ea
--- /dev/null
+++ b/examples/hash/sm3_hash_rmf.cpp
@@ -0,0 +1,103 @@
+/*************************************************************************
+* Copyright (C) 2024 Intel Corporation
+*
+* Licensed under the Apache License,  Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* 	http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law  or agreed  to  in  writing,  software
+* distributed under  the License  is  distributed  on  an  "AS IS"  BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the  specific  language  governing  permissions  and
+* limitations under the License.
+*************************************************************************/
+
+/*!
+  *
+  *  \file
+  *
+  *  \brief SM3 Hash example
+  *
+  *  This example demonstrates usage of Hash algorithms to digest a message by
+  *  using SM3 standard.
+  *  Reduce Memory Footprint (_rmf) APIs are used in this example.
+  *
+  */
+
+#include <string.h>
+#include <vector>
+
+#include "ippcp.h"
+#include "examples_common.h"
+
+/*! Message text */
+const Ipp8u msg[] = "abc";
+
+/*! Known digest to check the results */
+const
+Ipp8u sm3[] = "\x66\xc7\xf0\xf4\x62\xee\xed\xd9\xd1\xf2\xd4\x6b\xdc\x10\xe4\xe2"
+              "\x41\x67\xc4\x87\x5c\xf2\xf7\xa2\x29\x7d\xa0\x2b\x8f\x4b\xa8\xe0";
+
+/*! Message size in bytes */
+const int msg_byte_len = sizeof(msg)-1;
+
+int main(void)
+{
+    /*! Internal function status */
+    IppStatus status = ippStsNoErr;
+
+    /*! 1. Get the hash methods which is used */
+    const IppsHashMethod* hash_method = ippsHashMethod_SM3();
+
+    /*! The digest size of the SM3 standard */
+    Ipp32u hash_size = IPP_SM3_DIGEST_BYTESIZE;
+
+    /*! The size of the SM3 hash context structure. It will be set up in ippsHashGetSize_rmf(). */
+    int context_size = 0;
+
+    /*! 2. Get the size needed for the SM3 hash context structure */
+    status = ippsHashGetSize_rmf(&context_size);
+    if (!checkStatus("ippsHashGetSize", ippStsNoErr, status)) {
+        return status;
+    }
+
+    /*! 3. Allocate memory for the SM3 hash context structure */
+    std::vector<Ipp8u> context_buffer(context_size);
+
+    /*! 4. Buffers for the digest and the tag */
+    Ipp8u output_hash_buffer[IPP_SM3_DIGEST_BYTESIZE];
+
+    IppsHashState_rmf* hash_state = (IppsHashState_rmf*)(context_buffer.data());
+
+    /*! 5. Initialize the initial SM3 hash context */
+    status = ippsHashInit_rmf(hash_state, hash_method);
+    if (!checkStatus("ippsHashInit", ippStsNoErr, status)) {
+        return status;
+    }
+
+    /*! 6. Call HashUpdate function to digest the message of the given length */
+    /*! This function can be called multiple times for a stream of messages */
+    status = ippsHashUpdate_rmf(msg, msg_byte_len, hash_state);
+    if (!checkStatus("ippsHashUpdate", ippStsNoErr, status)) {
+        return status;
+    }
+
+    /*! 7. Complete the computation of the digest value */
+    status = ippsHashFinal_rmf(output_hash_buffer, hash_state);
+    if (!checkStatus("ippsHashFinal", ippStsNoErr, status)) {
+        return status;
+    }
+
+    /*! 8. Verify the resulted digest with the known one */
+    int check = memcmp(output_hash_buffer, sm3, hash_size);
+    if(check != 0) {
+        printf("ERROR: Hash and the reference do not match\n");
+        status = -1;
+    }
+
+    PRINT_EXAMPLE_STATUS("ippsHashUpdate_rmf", "SM3 Hash", !status)
+
+    return status;
+}
diff --git a/examples/post-quantum/lms_m32_h5_w8_verification.cpp b/examples/post-quantum/lms_m32_h5_w8_verification.cpp
new file mode 100644
index 0000000..2261f6b
--- /dev/null
+++ b/examples/post-quantum/lms_m32_h5_w8_verification.cpp
@@ -0,0 +1,213 @@
+/*************************************************************************
+* Copyright (C) 2024 Intel Corporation
+*
+* Licensed under the Apache License,  Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* 	http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law  or agreed  to  in  writing,  software
+* distributed under  the License  is  distributed  on  an  "AS IS"  BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the  specific  language  governing  permissions  and
+* limitations under the License.
+*************************************************************************/
+
+/*!
+  *
+  *  \file
+  *
+  *  \brief Leighton-Micali Hash-Based Signatures (LMS) example
+  *
+  *  This example demonstrates usage of LMS signatures verification.
+  *
+  *  The LMS algorithm is implemented according to the
+  *  "Leighton-Micali Hash-Based Signatures" document:
+  *
+  *  https://datatracker.ietf.org/doc/html/rfc8554
+  *
+  */
+
+/*! Define the macro to enable LMS usage */
+#define IPPCP_PREVIEW_LMS
+
+#include <memory>
+
+#include "ippcp.h"
+#include "examples_common.h"
+
+
+/*! Algorithm ID for LMS */
+IppsLMSAlgo lmsAlgo = IppsLMSAlgo::LMS_SHA256_M32_H5; //0x00000005
+
+/*! Algorithm ID for OTS (one-time signature) */
+IppsLMOTSAlgo lmotsAlgo = IppsLMOTSAlgo::LMOTS_SHA256_N32_W8; //0x00000004
+
+/*! Index of the LMS leaf */
+static Ipp32u q = 0x00000009;
+
+/*! Pointer to the LMS private key identifier */
+static Ipp8u pI[]        = { 0x05,0xbd,0x3d,0x90,0xcc,0xa2,0x47,0x08,0xe4,0x20,0x55,0x3e,0x5a,0xf7,0xb9,0xc8 };
+
+/*! Pointer to the LMS public key */
+static Ipp8u pK[]        = { 0x21,0xf9,0xd9,0x09,0x97,0x11,0xef,0x5b,0x14,0x50,0x0b,0x6a,0x18,0x1e,0x73,0x9e,
+                             0xd3,0x12,0x74,0xdb,0x72,0xac,0xe7,0xcf,0x29,0x32,0x9a,0x45,0xe8,0xde,0x11,0xfe };
+
+/*! Message */
+static Ipp8u pMsg[]       = { 0x04,0x3d,0x64,0x00,0x10,0x3b,0x16,0x0c,0xf1,0x89,0xb4,0xcf,0xff,0x08,0x06,0xfe,
+                             0xe3,0xe1,0x56,0x7f,0x2c,0x31,0x71,0x0f,0x82,0x84,0x52,0x74,0xf6,0xed,0x23,0x8e,
+                             0x14,0xde,0x4d,0x53,0x99,0x86,0x88,0x99,0xab,0x6b,0xcf,0x00,0x98,0x08,0xb8,0xca,
+                             0x30,0x81,0xed,0x11,0xaa,0x70,0x35,0x52,0x90,0xfd,0x86,0x98,0xd4,0xc1,0x77,0xc1,
+                             0x89,0x4c,0xd8,0xb8,0xd3,0x36,0x7f,0xd0,0xf3,0x00,0xef,0x62,0x83,0x02,0x0d,0x09,
+                             0x1c,0x27,0x35,0x6d,0xaf,0xad,0xdb,0xed,0x96,0x21,0x8a,0x19,0x56,0x7b,0x99,0x9a,
+                             0xcd,0x53,0x02,0xa5,0x11,0xd4,0xf1,0x65,0xef,0x9c,0xbe,0x85,0x5d,0xcc,0x73,0x1b,
+                             0x16,0xdd,0x13,0x6e,0x5c,0x44,0x15,0x8b,0xf1,0xe9,0x8c,0xc5,0x9c,0x6f,0x6c,0xb2 };
+
+/*! Pointer to the C LM-OTS value */
+static Ipp8u pC[]        = { 0x67,0x79,0x57,0x17,0x51,0x05,0x2c,0xe8,0xfe,0xe9,0x23,0xda,0x26,0xef,0x27,0x1e,
+                             0x62,0xbe,0x08,0x43,0xaa,0xdf,0x7c,0x69,0x19,0x68,0x43,0x32,0x8c,0xb0,0x4e,0x3d };
+
+/*! Pointer to the y LM-OTS value */
+static Ipp8u pY[]        = { 0x57,0x71,0xa7,0x12,0x2b,0x87,0xf2,0xbd,0x61,0x11,0x9c,0xd4,0x20,0x56,0xec,0x04,
+                             0xc0,0x60,0xbe,0x2a,0xe2,0xc2,0xd6,0x72,0xa8,0x1f,0x1a,0x4a,0x6a,0x76,0xc2,0x4c,
+                             0x01,0xa0,0x69,0x63,0x7f,0x85,0xdd,0xb4,0x5d,0x8d,0x19,0xd7,0xef,0x7c,0xc8,0x9a,
+                             0x47,0xfe,0x1e,0x79,0xfd,0x80,0x65,0x51,0x17,0xed,0xb6,0x3f,0x17,0xd0,0xb6,0xcc,
+                             0x0f,0xca,0xa9,0x28,0xc2,0xef,0x1e,0x41,0x4e,0xf7,0x34,0xa8,0xda,0xfe,0xbc,0x82,
+                             0xdb,0x33,0x3e,0x03,0xba,0x51,0x40,0x6e,0x07,0x6b,0xfc,0x2d,0x3e,0x81,0x30,0x09,
+                             0xd9,0x68,0xa8,0x71,0x00,0xf0,0x33,0xcf,0x0b,0x57,0x04,0xfc,0x4e,0x61,0x8a,0xa5,
+                             0x80,0xa1,0xe0,0x48,0xef,0xc3,0xd5,0x6e,0xe7,0xa2,0xea,0x02,0x14,0xa6,0xfe,0x1f,
+                             0x39,0xa4,0xf2,0xfb,0x61,0x2f,0x44,0xbe,0xde,0xd3,0x73,0x34,0x0e,0x76,0x48,0x27,
+                             0xc5,0xc5,0x8c,0xb9,0x07,0xcd,0x08,0xdd,0xfb,0xde,0x01,0xbb,0x11,0xff,0x3a,0x89,
+                             0xff,0xaa,0xd8,0xcd,0x7c,0x17,0x02,0x71,0x08,0x3c,0xe5,0x0f,0x0f,0xb9,0xea,0xbb,
+                             0xa8,0x9d,0xb6,0x0b,0x00,0x73,0xe7,0xaf,0xc8,0x1e,0x4c,0x6f,0x82,0x4a,0xef,0x09,
+                             0xf8,0xbf,0xc9,0x49,0x67,0x16,0x9b,0xcf,0xa0,0x84,0x76,0x55,0x57,0x41,0x10,0x19,
+                             0x37,0x0b,0x29,0xba,0x0d,0x32,0xa8,0x8e,0x84,0x2c,0x19,0xdf,0x14,0x5a,0x69,0x36,
+                             0x8d,0xf7,0xe1,0x55,0x7d,0x93,0x7a,0xae,0xdb,0x07,0xf6,0xbc,0xda,0xf9,0x78,0xeb,
+                             0x9e,0x50,0xf3,0xc8,0x47,0x38,0x2a,0xd4,0x3b,0xfc,0xc0,0xe0,0xd0,0xbf,0xd8,0x60,
+                             0x46,0x63,0xc7,0xfb,0xa8,0x84,0x45,0x4d,0x23,0x98,0x96,0xd8,0xff,0x8a,0x99,0xa3,
+                             0x34,0xf0,0xd3,0x32,0x22,0xaa,0x15,0xbd,0x47,0x9f,0xcd,0x49,0x52,0x0b,0x5b,0x2d,
+                             0x83,0xd8,0xbf,0x4d,0xbd,0x3d,0x7e,0x9d,0xc8,0x0b,0x62,0x0c,0xc7,0x03,0x45,0x7f,
+                             0x55,0x90,0x35,0xdd,0x1f,0x53,0xdc,0xec,0x0b,0x4d,0x89,0xca,0xb1,0xa3,0xb8,0x87,
+                             0x7b,0x31,0x1c,0x24,0x90,0x44,0x9d,0xf7,0xa6,0x1c,0xf8,0xed,0xf3,0x29,0xd6,0x96,
+                             0x26,0xca,0x42,0x4b,0xdf,0x61,0x00,0x91,0x92,0x08,0x37,0x76,0xbb,0x96,0x9e,0xd5,
+                             0x8d,0x76,0xa9,0x52,0x40,0xdb,0x3f,0xd6,0xec,0xa0,0x06,0x89,0x88,0x11,0x18,0x38,
+                             0xae,0xcb,0xa0,0x71,0xab,0x3b,0x7b,0xe0,0x94,0x30,0x59,0x38,0xaf,0xb0,0x8c,0xdd,
+                             0xf9,0xcd,0xaf,0x82,0x49,0x90,0x29,0xf6,0x24,0x9a,0xa5,0x51,0x1b,0x99,0x45,0x64,
+                             0x13,0x94,0x9e,0x3e,0x4e,0x43,0x40,0x73,0x0d,0x68,0x0b,0x68,0xde,0xb5,0xc9,0xd5,
+                             0xce,0xef,0x7b,0x8b,0x1e,0xd9,0x7e,0xc8,0xa1,0x69,0xb5,0x2b,0xd0,0x54,0xb0,0x53,
+                             0x41,0x9f,0xfa,0x77,0x34,0x55,0xcd,0xf4,0x79,0xa6,0x0d,0x3c,0xc7,0x05,0xd8,0xf2,
+                             0x08,0x48,0x32,0xb7,0x96,0x22,0xb6,0xe5,0xac,0x83,0x06,0xa7,0x68,0x3f,0xea,0x03,
+                             0xcd,0x79,0xe8,0xff,0x54,0xe2,0xf5,0xa0,0x6b,0x69,0xc1,0xca,0xb3,0xd4,0x2b,0x60,
+                             0xa8,0xa8,0xbe,0xcb,0x9e,0x94,0x2e,0xf1,0xfc,0xd7,0x55,0xac,0x08,0xd7,0xc4,0x22,
+                             0x4f,0xf3,0xf5,0xbf,0x49,0xb8,0xf7,0x5f,0xae,0x60,0x92,0xe4,0x3a,0x8f,0x30,0x35,
+                             0x41,0x8c,0xd4,0x03,0x31,0x6c,0x08,0xa8,0x08,0x37,0xb4,0x6c,0x22,0xca,0xa2,0xf7,
+                             0xff,0xc1,0x62,0x49,0xcd,0x5c,0x17,0x25,0xc5,0x4e,0xaa,0x26,0xb9,0xd7,0x72,0xf9,
+                             0x61,0x21,0xbf,0x95,0xda,0xcf,0x30,0x1d,0x42,0x8c,0x9d,0xf4,0x57,0x36,0x25,0xb7,
+                             0xfb,0xfa,0x64,0xba,0x7f,0x3e,0x0d,0x5a,0x72,0xa7,0x8d,0x13,0xf6,0x2d,0x57,0x76,
+                             0xa4,0x61,0x59,0x9d,0x4d,0xd5,0x99,0x0e,0xae,0x73,0x6b,0x6a,0xf1,0x64,0x93,0xf1,
+                             0xa7,0xd0,0xe4,0x4f,0x2b,0x71,0xd9,0x6e,0x0e,0x89,0x28,0x5a,0xec,0xc1,0x15,0x50,
+                             0x81,0x21,0x6c,0xe0,0xba,0xbb,0xce,0x4f,0x4e,0x0b,0x80,0xa1,0x92,0x6a,0xea,0x6a,
+                             0xcb,0x3e,0xa3,0xcb,0x7a,0x23,0x61,0x5d,0x41,0x08,0xba,0xf4,0x51,0x9b,0xf7,0x10,
+                             0x27,0x0e,0x89,0x6b,0x42,0xc5,0x5c,0x3c,0x9e,0x60,0x42,0x43,0x29,0xbf,0xbc,0x8a,
+                             0xd5,0x9f,0x4c,0xa2,0x0b,0x5e,0xbb,0xa4,0x93,0xe0,0xb3,0x9d,0xb9,0x7e,0xc7,0x9b,
+                             0x36,0x2a,0xc7,0x21,0x5e,0x25,0x5d,0xeb,0x74,0x68,0xfd,0xf4,0x0e,0x0f,0x39,0x0c,
+                             0x65,0x0c,0x66,0x51,0x0c,0xf4,0xad,0x9c,0x44,0x94,0x34,0xae,0x25,0x8b,0x56,0x1e,
+                             0x8e,0xc1,0x57,0x29,0xa6,0x90,0x62,0xb8,0xb2,0x8d,0x6c,0x79,0xf4,0x90,0x64,0xd2,
+                             0x4a,0x52,0xe9,0x15,0x95,0xc9,0x3f,0x83,0xc4,0x0f,0xec,0xa2,0x11,0xe2,0x8b,0x50,
+                             0x1f,0x13,0xcc,0x80,0x2f,0x0b,0x36,0x35,0x2c,0x85,0x41,0x79,0xd2,0xce,0x46,0x12,
+                             0xc7,0xf0,0xd3,0x96,0x04,0x4d,0x1c,0x69,0x4f,0x8f,0xe3,0xa0,0x1c,0xe2,0xa8,0x8c,
+                             0xe8,0xd1,0x74,0xca,0x66,0x99,0x1b,0x9d,0x6c,0x50,0x72,0xf2,0xd2,0x01,0x60,0xdf,
+                             0x74,0x81,0xaf,0xbd,0x7a,0xc9,0xd2,0xf7,0x5a,0x7d,0xfe,0x36,0x9c,0x61,0xed,0xc9,
+                             0xfb,0x27,0xbb,0xa3,0xd8,0x71,0x3c,0x57,0x5d,0xdd,0xab,0xcc,0x27,0xc6,0xb9,0x42,
+                             0x9b,0xcb,0x7e,0xec,0xf8,0x53,0x2e,0xf0,0xf4,0xc9,0x46,0x46,0xd8,0x94,0xd6,0xf7,
+                             0x8d,0x64,0xd7,0xba,0xb1,0x39,0x8e,0x7f,0xef,0xfd,0xb0,0xb0,0x31,0x4f,0x43,0x0f,
+                             0xec,0xa8,0x70,0x57,0x3a,0xe3,0x88,0xbc,0xa7,0xd9,0xf9,0x39,0xa4,0xb9,0x91,0x59,
+                             0xc7,0xbf,0xec,0x78,0xa9,0xce,0x33,0x99,0xf3,0x83,0xfa,0xaf,0x59,0xab,0x65,0xc6,
+                             0xe2,0xaa,0x30,0x08,0xd7,0x99,0x71,0x65,0xf1,0xb6,0xfc,0x4f,0xf1,0x68,0xa2,0xd8,
+                             0x61,0x8a,0xe5,0x0f,0x2b,0x60,0xda,0x8d,0xea,0x7e,0xf6,0x2c,0xae,0xeb,0x26,0xae,
+                             0x29,0x5d,0xab,0xc7,0x3f,0x27,0x2c,0x51,0xf1,0x3f,0x22,0x22,0xef,0x52,0x4e,0xcb,
+                             0x70,0xd8,0xba,0x41,0x53,0xb4,0xd9,0xdd,0xdc,0xe8,0xcd,0x7f,0xc1,0xb8,0x2b,0x8e,
+                             0x3b,0x3b,0x86,0xd7,0x4c,0x36,0x69,0xf6,0x31,0xcf,0x37,0xbd,0x16,0xe9,0x2f,0x4f,
+                             0xf9,0x13,0x19,0xf2,0x3b,0x41,0x1c,0x78,0x62,0x9c,0x5f,0x95,0xab,0xdd,0x17,0xe7,
+                             0x2e,0x8f,0x92,0x79,0xe0,0xeb,0xe0,0x49,0x58,0x6d,0x3c,0x26,0xb8,0x5c,0x93,0xb9,
+                             0xd7,0x6e,0xca,0x28,0x70,0x9c,0xbe,0xef,0x08,0x4e,0xe2,0x20,0x3a,0xdb,0x92,0x0b,
+                             0x29,0x2f,0xfd,0xc8,0x3a,0x4a,0x7c,0xa4,0x87,0x6f,0x33,0x8d,0x8e,0x7f,0x51,0x6f,
+                             0xab,0x11,0x42,0xc3,0x75,0xed,0x69,0xb1,0xf1,0x32,0xd8,0xd8,0xe2,0xc2,0x0d,0x52,
+                             0x21,0xad,0x97,0x05,0x60,0x1d,0x43,0x52,0x4c,0xb1,0x61,0x49,0xef,0x2c,0xc1,0xad,
+                             0x4c,0x0c,0xe7,0x1b,0x81,0xc6,0x2f,0x47,0xe2,0xb0,0xe6,0x6c,0xb8,0xd0,0x2d,0xe4,
+                             0x46,0xd2,0x0a,0x13,0xab,0xb3,0xb9,0x13,0x9e,0x41,0xba,0x06,0x2d,0x11,0xe4,0xe6 };
+
+/*! Pointer to the LMS authorization path */
+static Ipp8u pAuthPath[] = { 0xc7,0x14,0x06,0x72,0xbf,0x82,0x00,0x91,0xe3,0xd5,0xd6,0x4c,0x2a,0x71,0x21,0x83,
+                             0x3b,0xea,0xb1,0x16,0x74,0xd8,0xae,0x4e,0xe3,0x15,0xe7,0x85,0x4d,0xa7,0xa1,0x00,
+                             0x4b,0x2b,0x7b,0xc6,0xad,0x89,0xa8,0x6c,0xe8,0xf6,0x60,0x22,0x19,0xb9,0xc3,0x37,
+                             0x5b,0xca,0x93,0xf1,0x0e,0xa3,0x2f,0x10,0xfb,0x2f,0x39,0x21,0x1c,0x33,0x78,0xb7,
+                             0x89,0x0f,0x77,0x18,0xe8,0x73,0x04,0x54,0x71,0x08,0x0b,0x86,0x94,0x9e,0xc7,0x55,
+                             0x25,0xb9,0x4a,0xe1,0xbb,0x45,0x06,0x00,0x66,0xdf,0x75,0x17,0x8b,0x0d,0xc3,0xa6,
+                             0x65,0x9a,0x5e,0xc7,0x5d,0xe5,0xc1,0x29,0x1f,0x5f,0xfc,0xcb,0x89,0x84,0x5c,0xfb,
+                             0x7a,0x81,0xe2,0x54,0x05,0xd1,0x90,0xe3,0x7d,0xe4,0x3c,0x9f,0xe2,0xdc,0xd3,0xfd,
+                             0x7e,0x6e,0x72,0xfa,0xc7,0xbe,0xcb,0xd5,0xd0,0x1e,0xc4,0xae,0x48,0x9a,0x92,0x45,
+                             0xc3,0xc2,0xc1,0x06,0x91,0xbe,0x15,0x1f,0xa6,0xa1,0x87,0xbb,0x7c,0x68,0x7b,0xb8 };
+
+int main(void)
+{
+    /* Internal function status */
+    IppStatus status = ippStsNoErr;
+
+    /* Deleter to use in unique_ptr to clean the memory during the object's destruction */
+    auto toIpp8uDeleter = [] (auto* pData) { delete[] (Ipp8u*)pData; };
+
+    const Ipp32s msgLen = sizeof(pMsg);
+
+    /* Create an algorithm ID to put into the ippsLMS functions */
+    const IppsLMSAlgoType lmsAlgTypePk = { lmotsAlgo, lmsAlgo };
+
+    /* 1. Get the scratch buffer size */
+    int buffSize;
+    status = ippsLMSBufferGetSize(&buffSize, msgLen, lmsAlgTypePk);
+    if (!checkStatus("ippsLMSBufferGetSize", ippStsNoErr, status))
+        return status;
+    /* 2. Allocate memory for the scratch buffer */
+    std::unique_ptr<Ipp8u> pScratchBuffer(new Ipp8u[buffSize]);
+
+    /* 3. Get the LMS public key state size */
+    int ippcpPubKeySize;
+    status = ippsLMSPublicKeyStateGetSize(&ippcpPubKeySize, lmsAlgTypePk);
+    if (!checkStatus("ippsLMSPublicKeyStateGetSize", ippStsNoErr, status))
+        return status;
+
+    /* 4. Allocate memory for the LMS public key state */
+    std::unique_ptr<IppsLMSPublicKeyState, decltype(toIpp8uDeleter)>
+                    pPubKey((IppsLMSPublicKeyState *)(new Ipp8u[ippcpPubKeySize]), toIpp8uDeleter);
+
+    /* 5. Set the LMS public key */
+    status = ippsLMSSetPublicKeyState(lmsAlgTypePk, pI, pK, pPubKey.get());
+    if (!checkStatus("ippsLMSSetPublicKeyState", ippStsNoErr, status))
+        return status;
+
+    /* 6. Get the LMS signature state size */
+    int sigBuffSize;
+    status = ippsLMSSignatureStateGetSize(&sigBuffSize, lmsAlgTypePk);
+    if (!checkStatus("ippsLMSSignatureStateGetSize", ippStsNoErr, status))
+        return status;
+
+    /* 7. Allocate memory for the LMS signature buffer */
+    std::unique_ptr<IppsLMSSignatureState, decltype(toIpp8uDeleter)>
+                   pSignature((IppsLMSSignatureState *)(new Ipp8u[sigBuffSize]), toIpp8uDeleter);
+
+    /* 8. Set the LMS signature */
+    status = ippsLMSSetSignatureState(lmsAlgTypePk, q, pC, pY, pAuthPath, pSignature.get());
+    if (!checkStatus("ippsLMSSetSignatureState", ippStsNoErr, status))
+        return status;
+
+    int is_valid = 0;
+    /* 9. Verify the LMS signature */
+    status = ippsLMSVerify(pMsg, msgLen, pSignature.get(), &is_valid, pPubKey.get(), pScratchBuffer.get());
+    if (!checkStatus("ippsLMSVerify", ippStsNoErr, status))
+        return status;
+
+    PRINT_EXAMPLE_STATUS("ippsLMSVerify", "LMS Verification", 1 == is_valid);
+
+    return status;
+}
diff --git a/examples/utils/examples_common.h b/examples/utils/examples_common.h
index adbbff0..c0f230c 100644
--- a/examples/utils/examples_common.h
+++ b/examples/utils/examples_common.h
@@ -14,12 +14,12 @@
 * limitations under the License.
 *************************************************************************/
 
-/* Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography) */
+/* Intel® Cryptography Primitives Library */
 
 /*!
   *
   * \file
-  * \brief Common header for Intel IPP Cryptography examples
+  * \brief Common header for Intel Cryptography Primitives Library examples
   *
   */
 
diff --git a/include/ippcp.h b/include/ippcp.h
index f5cb74e..fc36e87 100644
--- a/include/ippcp.h
+++ b/include/ippcp.h
@@ -16,7 +16,7 @@
 
 /*
 //
-//   Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+//   Intel® Cryptography Primitives Library
 //
 */
 
@@ -48,16 +48,20 @@ extern "C" {
 #endif
 
 /* /////////////////////////////////////////////////////////////////////////////
-//  Name:       ippcpGetLibVersion
+//  Name:       ippcpGetLibVersion / CryptoLibraryVersion
 //  Purpose:    getting of the library version
-//  Returns:    the structure of information about version of ippCP library
+//  Returns:    the structure of information about version of Intel Cryptography Primitives Library
 //  Parameters:
 //
 //  Notes:      not necessary to release the returned structure
 */
-IPPAPI( const IppLibraryVersion*, ippcpGetLibVersion, (void) )
+#define LIB_VERSION_DEPRECATED "ippcpGetLibVersion API is deprecated and will be removed in one of future Intel® Cryptography Primitives Library releases. \
+Please use cryptoGetLibVersion instead."
 
+IPP_DEPRECATED(LIB_VERSION_DEPRECATED) \
+IPPAPI( const IppLibraryVersion*, ippcpGetLibVersion, (void) )
 
+IPPAPI( const CryptoLibraryVersion*, cryptoGetLibVersion, (void) )
 /*
 // =========================================================
 // Symmetric Ciphers
@@ -370,7 +374,7 @@ IPPAPI(IppStatus, ippsAES_CMACGetTag,(Ipp8u* pMD, int mdLen, const IppsAES_CMACS
 */
 
 #define RC4_DEPRECATED "is deprecated. This algorithm is considered weak due to known attacks on it. \
-It is obsolete and will be removed in one of the future Intel IPP Cryptography releases."
+It is obsolete and will be removed in one of the future Intel Cryptography Primitives Library releases."
 
 IPP_DEPRECATED(RC4_DEPRECATED) \
 IPPAPI(IppStatus, ippsARCFourCheckKey, (const Ipp8u *pKey, int keyLen, IppBool* pIsWeak))
@@ -399,172 +403,14 @@ IPPAPI(IppStatus, ippsARCFourDecrypt, (const Ipp8u *pSrc, Ipp8u *pDst, int lengt
 // =========================================================
 */
 
-#define OBSOLETE_API "is deprecated. This API is considered obsolete and will be removed in one of future Intel IPP Cryptography releases. \
-Use the following link for opening a ticket and providing feedback: https://supporttickets.intel.com/ if you have concerns."
-
 #define SHA1_DEPRECATED "This algorithm is considered weak due to known attacks on it. \
 The functionality remains in the library, but the implementation will no be longer \
 optimized and no security patches will be applied. A more secure alternative is available: SHA-2"
 
-/* SHA1 Hash Primitives */
-IPP_DEPRECATED(SHA1_DEPRECATED) \
-IPPAPI(IppStatus, ippsSHA1GetSize,(int* pSize))
-IPP_DEPRECATED(SHA1_DEPRECATED) \
-IPPAPI(IppStatus, ippsSHA1Init,(IppsSHA1State* pState))
-IPP_DEPRECATED(SHA1_DEPRECATED) \
-IPPAPI(IppStatus, ippsSHA1Duplicate,(const IppsSHA1State* pSrcState, IppsSHA1State* pDstState))
-
-IPP_DEPRECATED(SHA1_DEPRECATED) \
-IPPAPI(IppStatus, ippsSHA1Pack,(const IppsSHA1State* pState, Ipp8u* pBuffer))
-IPP_DEPRECATED(SHA1_DEPRECATED) \
-IPPAPI(IppStatus, ippsSHA1Unpack,(const Ipp8u* pBuffer, IppsSHA1State* pState))
-
-IPP_DEPRECATED(SHA1_DEPRECATED) \
-IPPAPI(IppStatus, ippsSHA1Update,(const Ipp8u* pSrc, int len, IppsSHA1State* pState))
-IPP_DEPRECATED(SHA1_DEPRECATED) \
-IPPAPI(IppStatus, ippsSHA1GetTag,(Ipp8u* pTag, Ipp32u tagLen, const IppsSHA1State* pState))
-IPP_DEPRECATED(SHA1_DEPRECATED) \
-IPPAPI(IppStatus, ippsSHA1Final,(Ipp8u* pMD, IppsSHA1State* pState))
-IPP_DEPRECATED(SHA1_DEPRECATED) \
-IPPAPI(IppStatus, ippsSHA1MessageDigest,(const Ipp8u* pMsg, int len, Ipp8u* pMD))
-
-/* SHA224 Hash Primitives */
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA224GetSize,(int* pSize))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA224Init,(IppsSHA224State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA224Duplicate,(const IppsSHA224State* pSrcState, IppsSHA224State* pDstState))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA224Pack,(const IppsSHA224State* pState, Ipp8u* pBuffer))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA224Unpack,(const Ipp8u* pBuffer, IppsSHA224State* pState))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA224Update,(const Ipp8u* pSrc, int len, IppsSHA224State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA224GetTag,(Ipp8u* pTag, Ipp32u tagLen, const IppsSHA224State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA224Final,(Ipp8u* pMD, IppsSHA224State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA224MessageDigest,(const Ipp8u* pMsg, int len, Ipp8u* pMD))
-
-/* SHA256 Hash Primitives */
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA256GetSize,(int* pSize))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA256Init,(IppsSHA256State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA256Duplicate,(const IppsSHA256State* pSrcState, IppsSHA256State* pDstState))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA256Pack,(const IppsSHA256State* pState, Ipp8u* pBuffer))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA256Unpack,(const Ipp8u* pBuffer, IppsSHA256State* pState))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA256Update,(const Ipp8u* pSrc, int len, IppsSHA256State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA256GetTag,(Ipp8u* pTag, Ipp32u tagLen, const IppsSHA256State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA256Final,(Ipp8u* pMD, IppsSHA256State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA256MessageDigest,(const Ipp8u* pMsg, int len, Ipp8u* pMD))
-
-/* SHA384 Hash Primitives */
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA384GetSize,(int* pSize))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA384Init,(IppsSHA384State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA384Duplicate,(const IppsSHA384State* pSrcState, IppsSHA384State* pDstState))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA384Pack,(const IppsSHA384State* pState, Ipp8u* pBuffer))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA384Unpack,(const Ipp8u* pBuffer, IppsSHA384State* pState))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA384Update,(const Ipp8u* pSrc, int len, IppsSHA384State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA384GetTag,(Ipp8u* pTag, Ipp32u tagLen, const IppsSHA384State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA384Final,(Ipp8u* pMD, IppsSHA384State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA384MessageDigest,(const Ipp8u* pMsg, int len, Ipp8u* pMD))
-
-/* SHA512 Hash Primitives */
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA512GetSize,(int* pSize))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA512Init,(IppsSHA512State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA512Duplicate,(const IppsSHA512State* pSrcState, IppsSHA512State* pDstState))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA512Pack,(const IppsSHA512State* pState, Ipp8u* pBuffer))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA512Unpack,(const Ipp8u* pBuffer, IppsSHA512State* pState))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA512Update,(const Ipp8u* pSrc, int len, IppsSHA512State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA512GetTag,(Ipp8u* pTag, Ipp32u tagLen, const IppsSHA512State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA512Final,(Ipp8u* pMD, IppsSHA512State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSHA512MessageDigest,(const Ipp8u* pMsg, int len, Ipp8u* pMD))
-
-/* MD5 Hash Primitives */
-
 #define MD5_DEPRECATED "This algorithm is considered weak due to known attacks on it. \
 The functionality remains in the library, but the implementation will no be longer \
 optimized and no security patches will be applied. A more secure alternative is available: SHA-2"
 
-IPP_DEPRECATED(MD5_DEPRECATED) \
-IPPAPI(IppStatus, ippsMD5GetSize,(int* pSize))
-IPP_DEPRECATED(MD5_DEPRECATED) \
-IPPAPI(IppStatus, ippsMD5Init,(IppsMD5State* pState))
-IPP_DEPRECATED(MD5_DEPRECATED) \
-IPPAPI(IppStatus, ippsMD5Duplicate,(const IppsMD5State* pSrcState, IppsMD5State* pDstState))
-
-IPP_DEPRECATED(MD5_DEPRECATED) \
-IPPAPI(IppStatus, ippsMD5Pack,(const IppsMD5State* pState, Ipp8u* pBuffer))
-IPP_DEPRECATED(MD5_DEPRECATED) \
-IPPAPI(IppStatus, ippsMD5Unpack,(const Ipp8u* pBuffer, IppsMD5State* pState))
-
-IPP_DEPRECATED(MD5_DEPRECATED) \
-IPPAPI(IppStatus, ippsMD5Update,(const Ipp8u* pSrc, int len, IppsMD5State* pState))
-IPP_DEPRECATED(MD5_DEPRECATED) \
-IPPAPI(IppStatus, ippsMD5GetTag,(Ipp8u* pTag, Ipp32u tagLen, const IppsMD5State* pState))
-IPP_DEPRECATED(MD5_DEPRECATED) \
-IPPAPI(IppStatus, ippsMD5Final,(Ipp8u* pMD, IppsMD5State* pState))
-IPP_DEPRECATED(MD5_DEPRECATED) \
-IPPAPI(IppStatus, ippsMD5MessageDigest,(const Ipp8u* pMsg, int len, Ipp8u* pMD))
-
-/* SM3 Hash Primitives */
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSM3GetSize,(int* pSize))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSM3Init,(IppsSM3State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSM3Duplicate,(const IppsSM3State* pSrcState, IppsSM3State* pDstState))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSM3Pack,(const IppsSM3State* pState, Ipp8u* pBuffer))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSM3Unpack,(const Ipp8u* pBuffer, IppsSM3State* pState))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSM3Update,(const Ipp8u* pSrc, int len, IppsSM3State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSM3GetTag,(Ipp8u* pTag, Ipp32u tagLen, const IppsSM3State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSM3Final,(Ipp8u* pMD, IppsSM3State* pState))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsSM3MessageDigest,(const Ipp8u* pMsg, int len, Ipp8u* pMD))
-
 /* generalized Hash Primitives */
 IPP_DEPRECATED(OBSOLETE_API) \
 IPPAPI(IppStatus, ippsHashGetSize,(int* pSize))
@@ -774,6 +620,10 @@ IPPAPI(IppStatus, ippsMontMul, (const IppsBigNumState* pA, const IppsBigNumState
 IPPAPI(IppStatus, ippsMontExp, (const IppsBigNumState* pA, const IppsBigNumState* pE, IppsMontState* m, IppsBigNumState* pR))
 
 /* Pseudo-Random Number Generation */
+#define PRNG_DEPRECATED "This algorithm is considered weak since it's based on the outdated FIPS standard(FIPS 186-2). \
+The functionality remains in the library, but its implementation is not recommended for use. \
+A more secure alternative is available: ippsPRNGenRDRAND and ippsTRNGenRDSEED."
+
 IPPAPI(IppStatus, ippsPRNGGetSize,(int* pSize))
 IPPAPI(IppStatus, ippsPRNGInit,   (int seedBits, IppsPRNGState* pCtx))
 
@@ -783,7 +633,9 @@ IPPAPI(IppStatus, ippsPRNGSetAugment,(const IppsBigNumState* pAug, IppsPRNGState
 IPPAPI(IppStatus, ippsPRNGSetSeed,   (const IppsBigNumState* pSeed,IppsPRNGState* pCtx))
 IPPAPI(IppStatus, ippsPRNGGetSeed,   (const IppsPRNGState* pCtx,IppsBigNumState* pSeed))
 
+IPP_DEPRECATED(PRNG_DEPRECATED) \
 IPPAPI(IppStatus, ippsPRNGen,     (Ipp32u* pRand, int nBits, void* pCtx))
+IPP_DEPRECATED(PRNG_DEPRECATED) \
 IPPAPI(IppStatus, ippsPRNGen_BN,  (IppsBigNumState* pRand, int nBits, void* pCtx))
 IPPAPI(IppStatus, ippsPRNGenRDRAND,   (Ipp32u* pRand, int nBits, void* pCtx))
 IPPAPI(IppStatus, ippsPRNGenRDRAND_BN,(IppsBigNumState* pRand, int nBits, void* pCtx))
@@ -1079,201 +931,6 @@ IPPAPI(IppStatus, ippsDLPValidateDH,(int nTrials, IppDLResult* pResult, IppsDLPS
 IPPAPI( const char*, ippsECCGetResultString, (IppECResult code))
 
 /*
-// EC over Prime Fields
-*/
-/* general EC initialization */
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPGetSize,(int feBitSize, int* pSize))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPGetSizeStd128r1,(int* pSize))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPGetSizeStd128r2,(int* pSize))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPGetSizeStd192r1,(int* pSize))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPGetSizeStd224r1,(int* pSize))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPGetSizeStd256r1,(int* pSize))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPGetSizeStd384r1,(int* pSize))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPGetSizeStd521r1,(int* pSize))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPGetSizeStdSM2,  (int* pSize))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPInit,(int feBitSize, IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPInitStd128r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPInitStd128r2,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPInitStd192r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPInitStd224r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPInitStd256r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPInitStd384r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPInitStd521r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPInitStdSM2,  (IppsECCPState* pEC))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSet,(const IppsBigNumState* pPrime,
-                               const IppsBigNumState* pA, const IppsBigNumState* pB,
-                               const IppsBigNumState* pGX,const IppsBigNumState* pGY,const IppsBigNumState* pOrder,
-                               int cofactor,
-                               IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSetStd,(IppECCType flag, IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSetStd128r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSetStd128r2,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSetStd192r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSetStd224r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSetStd256r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSetStd384r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSetStd521r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSetStdSM2,  (IppsECCPState* pEC))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPBindGxyTblStd192r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPBindGxyTblStd224r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPBindGxyTblStd256r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPBindGxyTblStd384r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPBindGxyTblStd521r1,(IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPBindGxyTblStdSM2,  (IppsECCPState* pEC))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPGet,(IppsBigNumState* pPrime,
-                               IppsBigNumState* pA, IppsBigNumState* pB,
-                               IppsBigNumState* pGX,IppsBigNumState* pGY,IppsBigNumState* pOrder,
-                               int* cofactor,
-                               IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPGetOrderBitSize,(int* pBitSize, IppsECCPState* pEC))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPValidate,(int nTrials, IppECResult* pResult, IppsECCPState* pEC,
-                                    IppBitSupplier rndFunc, void* pRndParam))
-
-/* EC Point */
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPPointGetSize,(int feBitSize, int* pSize))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPPointInit,(int feBitSize, IppsECCPPointState* pPoint))
-
-/* Setup/retrieve point's coordinates */
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSetPoint,(const IppsBigNumState* pX, const IppsBigNumState* pY,
-                                    IppsECCPPointState* pPoint, IppsECCPState* pEC))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSetPointAtInfinity,(IppsECCPPointState* pPoint, IppsECCPState* pEC))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPGetPoint,(IppsBigNumState* pX, IppsBigNumState* pY,
-                                    const IppsECCPPointState* pPoint, IppsECCPState* pEC))
-
-/* EC Point Operations */
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPCheckPoint,(const IppsECCPPointState* pP,
-                                      IppECResult* pResult, IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPComparePoint,(const IppsECCPPointState* pP, const IppsECCPPointState* pQ,
-                                        IppECResult* pResult, IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPNegativePoint,(const IppsECCPPointState* pP,
-                                         IppsECCPPointState* pR, IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPAddPoint,(const IppsECCPPointState* pP, const IppsECCPPointState* pQ,
-                                    IppsECCPPointState* pR, IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPMulPointScalar,(const IppsECCPPointState* pP, const IppsBigNumState* pK,
-                                          IppsECCPPointState* pR, IppsECCPState* pEC))
-
-/* Key Generation, Setup and Validation */
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPGenKeyPair,(IppsBigNumState* pPrivate, IppsECCPPointState* pPublic,
-                                      IppsECCPState* pEC,
-                                      IppBitSupplier rndFunc, void* pRndParam))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPPublicKey,(const IppsBigNumState* pPrivate,
-                                     IppsECCPPointState* pPublic,
-                                     IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPValidateKeyPair,(const IppsBigNumState* pPrivate, const IppsECCPPointState* pPublic,
-                                           IppECResult* pResult,
-                                           IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSetKeyPair,(const IppsBigNumState* pPrivate, const IppsECCPPointState* pPublic,
-                                      IppBool regular,
-                                      IppsECCPState* pEC))
-
-/* Shared Secret (DH scheme ) */
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSharedSecretDH,(const IppsBigNumState* pPrivateA,
-                                          const IppsECCPPointState* pPublicB,
-                                          IppsBigNumState* pShare,
-                                          IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSharedSecretDHC,(const IppsBigNumState* pPrivateA,
-                                           const IppsECCPPointState* pPublicB,
-                                           IppsBigNumState* pShare,
-                                           IppsECCPState* pEC))
-
-/* Sign/Verify */
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSignDSA,(const IppsBigNumState* pMsgDigest,
-                        const IppsBigNumState* pPrivate,
-                        IppsBigNumState* pSignX, IppsBigNumState* pSignY,
-                        IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPVerifyDSA,(const IppsBigNumState* pMsgDigest,
-                        const IppsBigNumState* pSignX, const IppsBigNumState* pSignY,
-                        IppECResult* pResult,
-                        IppsECCPState* pEC))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSignNR,(const IppsBigNumState* pMsgDigest,
-                        const IppsBigNumState* pPrivate,
-                        IppsBigNumState* pSignX, IppsBigNumState* pSignY,
-                        IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPVerifyNR,(const IppsBigNumState* pMsgDigest,
-                        const IppsBigNumState* pSignX, const IppsBigNumState* pSignY,
-                        IppECResult* pResult,
-                        IppsECCPState* pEC))
-
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPSignSM2,(const IppsBigNumState* pMsgDigest,
-                        const IppsBigNumState* pRegPrivate,
-                        IppsBigNumState* pEphPrivate,
-                        IppsBigNumState* pSignR, IppsBigNumState* pSignS,
-                        IppsECCPState* pEC))
-IPP_DEPRECATED(OBSOLETE_API) \
-IPPAPI(IppStatus, ippsECCPVerifySM2,(const IppsBigNumState* pMsgDigest,
-                        const IppsECCPPointState* pRegPublic,
-                        const IppsBigNumState* pSignR, const IppsBigNumState* pSignS,
-                        IppECResult* pResult,
-                        IppsECCPState* pEC))
-
-/*
 // GF over prime and its extension
 */
 IPPAPI(IppStatus, ippsGFpGetSize, (int feBitSize, int* pSize))
diff --git a/include/ippcp/fips_cert.h b/include/ippcp/fips_cert.h
index 4feef86..92d3544 100644
--- a/include/ippcp/fips_cert.h
+++ b/include/ippcp/fips_cert.h
@@ -105,6 +105,10 @@ IPPAPI(fips_test_status, fips_selftest_ippsGFpECPublicKey, (Ipp8u *pGFpBuff, Ipp
 IPPAPI(fips_test_status, fips_selftest_ippsGFpECPrivateKey, (Ipp8u *pGFpBuff, Ipp8u *pGFpECBuff, Ipp8u *pDataBuff))
 IPPAPI(fips_test_status, fips_selftest_ippsGFpECSharedSecretDH, (Ipp8u *pGFpBuff, Ipp8u *pGFpECBuff, Ipp8u *pDataBuff))
 
+/* LMS */
+IPPAPI(fips_test_status, fips_selftest_ippsLMSVerify_get_size, (int *pBufferSize))
+IPPAPI(fips_test_status, fips_selftest_ippsLMSVerify, (Ipp8u *pDataBuff))
+
 /*
 // Enumerator that contains information about FIPS-approved
 // functions inside the ippcp cryptographic boundary
@@ -158,6 +162,7 @@ enum FIPS_IPPCP_FUNC {
     HMACMessage_rmf,
     RSAEncrypt_OAEP_rmf,
     RSADecrypt_OAEP_rmf,
+    LMSVerify,
 
   /* Not approved functions or
    * FIPS-mode is not yet implemented, < 0
@@ -222,8 +227,7 @@ enum FIPS_IPPCP_FUNC {
     GFpECESEncrypt_SM2,
     GFpECESDecrypt_SM2,
     GFpECESFinal_SM2,
-    XMSSVerify,
-    LMSVerify
+    XMSSVerify
 };
 
 /**
diff --git a/include/ippcpdefs.h b/include/ippcpdefs.h
index a1c4155..baee0ca 100644
--- a/include/ippcpdefs.h
+++ b/include/ippcpdefs.h
@@ -16,7 +16,7 @@
 
 /*
 //
-//              Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+//              Intel® Cryptography Primitives Library
 //
 //              Purpose: Basic Types and Macro Definitions
 //
@@ -68,6 +68,9 @@ extern "C" {
 #    define COMPILER_SUPPORT_SHORT_FLOAT _NO_FLOAT_16
 #endif
 
+#define OBSOLETE_API "is deprecated. This API is considered obsolete and will be removed in one of future Intel® Cryptography Primitives Library releases. \
+Use the following link for opening a ticket and providing feedback: https://supporttickets.intel.com/ if you have concerns."
+
 #if !defined(_NO_IPP_DEPRECATED)
    #if (defined( __ICL ) || defined( __ECL ) || defined(_MSC_VER)) && !defined( _PCS ) && !defined( _PCS_GENSTUBS )
      #if( __INTEL_COMPILER >= 1100 ) /* icl 11.0 supports additional comment */
@@ -194,6 +197,7 @@ extern "C" {
 
 #define IPP_ABS( a ) ( ((a) < 0) ? (-(a)) : (a) )
 
+/* IppLibraryVersion is deprecated, please use CryptoLibraryVersion instead */
 typedef struct {
     int          major;         /* e.g. 1                               */
     int          minor;         /* e.g. 2                               */
@@ -205,6 +209,16 @@ typedef struct {
     const char*  BuildDate;     /* e.g. "Jul 20 99"                     */
 } IppLibraryVersion;
 
+typedef struct {
+    int          major;         /* e.g. 1                               */
+    int          minor;         /* e.g. 2                               */
+    int          patch;         /* e.g. 3                               */
+    char         targetCpu[4];  /* corresponding to Intel® processor    */
+    const char*  name;          /* e.g. "ippsw7"                        */
+    const char*  buildDate;     /* e.g. "Jul 20 99"                     */
+    const char*  strVersion;    /* e.g. "v1.2 Beta"                     */
+} CryptoLibraryVersion;
+
 typedef unsigned char  Ipp8u;
 typedef unsigned short Ipp16u;
 typedef unsigned int   Ipp32u;
@@ -354,12 +368,14 @@ typedef enum {
  #define   ippCPUID_AVX512VBMI2  INT64_SUFFIX(0x2000000000)       /* Intel® Advanced Vector Extensions 512 Bit Manipulation instructions 2                */
  #define   ippCPUID_AVX512_FP16  INT64_SUFFIX(0x1000000000)       /* Intel(R) Advanced Vector Extensions 512 16-bit floating point (FP16) instruction set */
 
- #define   ippCPUID_AVX2VAES   INT64_SUFFIX(0x4000000000)         /* Intel® Advanced Vector Extensions 256 Bit Vector AES instructions                    */
+ #define   ippCPUID_AVX2VAES    INT64_SUFFIX(0x4000000000)        /* Intel® Advanced Vector Extensions 256 Bit Vector AES instructions                    */
  #define   ippCPUID_AVX2VCLMUL  INT64_SUFFIX(0x8000000000)        /* Intel® instruction VPCLMULQDQ                                                        */
-
+ #define   ippCPUID_AVX2SM3     INT64_SUFFIX(0x10000000000)       /* Intel® Advanced Vector Extensions 256 Bit SM3_NI instructions                        */
+ #define   ippCPUID_AVX2SM4     INT64_SUFFIX(0x20000000000)       /* Intel® Advanced Vector Extensions 256 Bit SM4_NI instructions                        */
+ #define   ippCPUID_AVX2SHA512  INT64_SUFFIX(0x40000000000)       /* Intel® Advanced Vector Extensions 256 Bit SHA512_NI instructions                     */
 #endif /* IPP_CPU_FEATURES__ */
 
-/* Macros are necessary to build custom Intel® IPP Cryptography static 1cpu library (enable specific features at compile-time) */
+/* Macros are necessary to build custom Intel® Cryptography Primitives Library static 1cpu library (enable specific features at compile-time) */
 #if (!defined(_MERGED_BLD) && defined(IPPCP_CUSTOM_BUILD))
 
 #ifndef IPP_CUSTOM_CPU_FEATURES__
@@ -391,7 +407,6 @@ extern "C" {
 #endif
 typedef signed int IppStatus;
 
-    /* start of common with ippCrypto part - any changes MUST be done in both repositories - IPP & ippCrypto                    */
 #define ippStsCpuNotSupportedErr         -9999 /* The target CPU is not supported.                                              */
 #define ippStsUnknownStatusCodeErr        -216 /* Unknown status code.                                                          */
 #define ippStsLoadDynErr                  -221 /* Error when loading the dynamic library.                                       */
@@ -415,7 +430,6 @@ typedef signed int IppStatus;
 #define ippStsDivByZero                      2 /* Zero value(s) for the divisor in the Div function. */
 #define ippStsWaterfall                     43 /* Cannot load required library, waterfall is used. */
 #define ippStsFeaturesCombination           51 /* Wrong combination of features. */
-    /* end of common with ippCrypto part */
 
 #ifdef __cplusplus
 }
@@ -423,13 +437,12 @@ typedef signed int IppStatus;
 
 #endif /* IPPSTATUS_H__ */
 
-     /* ippCrypto specific statuses - any changes MUST be done in both repositories - IPP & ippCrypto */
 #define ippStsInvalidPoint               -1017 /* ippStsInvalidPoint ECC: Invalid point (out of EC).*/
 #define ippStsQuadraticNonResidueErr     -1016 /* SQRT operation on quadratic non-residue value. */
 #define ippStsPointAtInfinity            -1015 /* Point at infinity is detected. */
-#define ippStsOFBSizeErr                 -1014 /* Incorrect value for crypto OFB block size. */
-#define ippStsIncompleteContextErr       -1013 /* Crypto: set up of context is not complete. */
-#define ippStsCTRSizeErr                 -1012 /* Incorrect value for crypto CTR block size. */
+#define ippStsOFBSizeErr                 -1014 /* Incorrect value for cryptography OFB block size. */
+#define ippStsIncompleteContextErr       -1013 /* Set up of context is not complete. */
+#define ippStsCTRSizeErr                 -1012 /* Incorrect value for cryptography CTR block size. */
 #define ippStsEphemeralKeyErr            -1011 /* ECC: Invalid ephemeral key. */
 #define ippStsMessageErr                 -1010 /* ECC: Invalid message digest. */
 #define ippStsShareKeyErr                -1009 /* ECC: Invalid share key. */
@@ -438,13 +451,12 @@ typedef signed int IppStatus;
 #define ippStsECCInvalidFlagErr          -1006 /* ECC: Invalid Flag. */
 #define ippStsUnderRunErr                -1005 /* Error in data under run. */
 #define ippStsPaddingErr                 -1004 /* Detected padding error indicates the possible data corruption. */
-#define ippStsCFBSizeErr                 -1003 /* Incorrect value for crypto CFB block size. */
+#define ippStsCFBSizeErr                 -1003 /* Incorrect value for cryptography CFB block size. */
 #define ippStsPaddingSchemeErr           -1002 /* Invalid padding scheme. */
 #define ippStsBadModulusErr              -1001 /* Bad modulus caused a failure in module inversion. */
 #define ippStsInsufficientEntropy           25 /* Generation of the prime/key failed due to insufficient entropy in the random seed and stimulus bit string. */
 #define ippStsNotSupportedCpu               36 /* The CPU is not supported. */
 #define ippStsMbWarning                     53 /* Error(s) in statuses array. */
-     /* end of ippCrypto specific statuses - any changes MUST be done in both repositories - IPP & ippCrypto */
 
 #if (!defined IPPCPDEFS_H__) || defined( _OWN_BLDPCS )
 #define IPPCPDEFS_H__
@@ -846,13 +858,19 @@ typedef struct _GFpECKeyExchangeSM2 IppsGFpECKeyExchangeSM2State;
 IPPAPI( IppStatus, ippcpGetCpuFeatures, ( Ipp64u* pFeaturesMask ))
 IPPAPI( IppStatus, ippcpSetCpuFeatures, ( Ipp64u features ))
 IPPAPI( Ipp64u, ippcpGetEnabledCpuFeatures, ( void ) )
-IPPAPI( IppStatus, ippcpSetNumThreads, ( int numThr ))
+
 IPPAPI( IppStatus, ippcpInit,( void ))
-IPPAPI( IppStatus, ippcpGetNumThreads, (int* pNumThr) )
 IPPAPI( const char*, ippcpGetStatusString, ( IppStatus StsCode ))
-IPPAPI( int, ippcpGetEnabledNumThreads, ( void ) )
 IPPAPI( Ipp64u, ippcpGetCpuClocks, (void) )
 
+/* Threading functions are deprecated in the library */
+IPP_DEPRECATED(OBSOLETE_API) \
+IPPAPI( IppStatus, ippcpSetNumThreads, ( int numThr ))
+IPP_DEPRECATED(OBSOLETE_API) \
+IPPAPI( IppStatus, ippcpGetNumThreads, (int* pNumThr) )
+IPP_DEPRECATED(OBSOLETE_API) \
+IPPAPI( int, ippcpGetEnabledNumThreads, ( void ) )
+
 /* Defines related to experimental features enabling */
 #ifdef IPPCP_PREVIEW_ALL
     #ifndef IPPCP_PREVIEW_XMSS
diff --git a/include/ippcpversion.h b/include/ippcpversion.h
new file mode 100755
index 0000000..3e98d16
--- /dev/null
+++ b/include/ippcpversion.h
@@ -0,0 +1,41 @@
+/*************************************************************************
+* Copyright (C) 2024 Intel Corporation
+*
+* Licensed under the Apache License,  Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* 	http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law  or agreed  to  in  writing,  software
+* distributed under  the License  is  distributed  on  an  "AS IS"  BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the  specific  language  governing  permissions  and
+* limitations under the License.
+*************************************************************************/
+
+/*
+//
+//              Intel® Cryptography Primitives Library
+//
+//              Purpose: Describes the Intel® Cryptography Primitives Library version
+//
+*/
+
+
+#if !defined( CRYPTOLIBVERSION_H__ )
+#define CRYPTOLIBVERSION_H__
+
+#define CRYPTO_LIB_VERSION_MAJOR  1
+#define CRYPTO_LIB_VERSION_MINOR  0
+#define CRYPTO_LIB_VERSION_PATCH 0
+
+// Major interface version
+#define CRYPTO_LIB_INTERFACE_VERSION_MAJOR 12
+// Minor interface version
+#define CRYPTO_LIB_INTERFACE_VERSION_MINOR 0
+
+#define CRYPTO_LIB_VERSION_STR  STR(CRYPTO_LIB_VERSION_MAJOR) "." STR(CRYPTO_LIB_VERSION_MINOR) "." STR(CRYPTO_LIB_VERSION_PATCH) \
+                                " (" STR(CRYPTO_LIB_INTERFACE_VERSION_MAJOR) "." STR(CRYPTO_LIB_INTERFACE_VERSION_MINOR) ")"
+
+#endif /* CRYPTOLIBVERSION_H__ */
diff --git a/include/ippversion.h b/include/ippversion.h
index a6459e8..7aa393f 100644
--- a/include/ippversion.h
+++ b/include/ippversion.h
@@ -15,25 +15,30 @@
 *************************************************************************/
 
 /*
-// 
-//              Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
 //
-//              Purpose: Describes the Intel IPP Cryptography version
+//              Intel® Cryptography Primitives Library
+//
+//              Purpose: Describes the Intel® Cryptography Primitives Library version
 //
 */
 
 
 #if !defined( IPPVERSION_H__ )
+
+#if !defined(_NO_IPP_DEPRECATED)
+#pragma message("Header `ippversion.h` is deprecated and will be removed in one of future Intel® Cryptography Primitives Library releases. Please use `ippcpversion.h` instead.")
+#endif /* !defined(_NO_IPP_DEPRECATED) */
+
 #define IPPVERSION_H__
 
-#define IPP_VERSION_MAJOR  2021
-#define IPP_VERSION_MINOR  12
-#define IPP_VERSION_UPDATE 1
+#define IPP_VERSION_MAJOR  1
+#define IPP_VERSION_MINOR  0
+#define IPP_VERSION_UPDATE 0
 
 // Major interface version
-#define IPP_INTERFACE_VERSION_MAJOR 11
+#define IPP_INTERFACE_VERSION_MAJOR 12
 // Minor interface version
-#define IPP_INTERFACE_VERSION_MINOR 15
+#define IPP_INTERFACE_VERSION_MINOR 0
 
 #define IPP_VERSION_STR  STR(IPP_VERSION_MAJOR) "." STR(IPP_VERSION_MINOR) "." STR(IPP_VERSION_UPDATE) " (" STR(IPP_INTERFACE_VERSION_MAJOR) "." STR(IPP_INTERFACE_VERSION_MINOR) " )"
 
diff --git a/sources/cmake/CMakeASM_NASMOptions.txt b/sources/cmake/CMakeASM_NASMOptions.txt
index f33025e..ab001c4 100644
--- a/sources/cmake/CMakeASM_NASMOptions.txt
+++ b/sources/cmake/CMakeASM_NASMOptions.txt
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
 if (UNIX)
diff --git a/sources/cmake/ippcp-config-version.cmake.in b/sources/cmake/ippcp-config-version.cmake.in
index 1065a9d..0b12305 100644
--- a/sources/cmake/ippcp-config-version.cmake.in
+++ b/sources/cmake/ippcp-config-version.cmake.in
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 # library detection routine (version compatibility rules).
 #
 
diff --git a/sources/cmake/ippcp-config.cmake.in b/sources/cmake/ippcp-config.cmake.in
index 520d9b9..1a4a3cc 100644
--- a/sources/cmake/ippcp-config.cmake.in
+++ b/sources/cmake/ippcp-config.cmake.in
@@ -15,8 +15,7 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
-# library detection routine.
+# Intel® Cryptography Primitives Library detection routine.
 #
 # To use it, add the lines below to your CMakeLists.txt:
 #    find_package(IPPCP REQUIRED)
@@ -50,7 +49,7 @@ endif()
 
 if (NOT IPPCP_FIND_COMPONENTS)
     set(IPPCP_FIND_COMPONENTS "ippcp")
-    
+
     # crypto_mb library is only for intel64
     if(${IPPCP_ARCH} MATCHES "intel64")
         set(IPPCP_BIN_REL_PATH    @IPPCP_BIN64_REL_PATH@)
@@ -99,14 +98,14 @@ macro(add_imported_library_target PATH_TO_LIBRARY PATH_TO_IMPORT_LIB LINKAGE_TYP
                     set_target_properties(IPPCP::${_component} PROPERTIES IMPORTED_IMPLIB "${PATH_TO_IMPORT_LIB}")
                 endif()
             else()
-                message(WARNING "IPPCP: Include directory does not exist: '${_include_dir}'. Intel IPP Cryptography installation might be broken.")
+                message(WARNING "Include directory does not exist: '${_include_dir}'. Intel Cryptography Primitives Library installation might be broken.")
             endif()
             unset(_include_dir)
         endif()
         list(APPEND IPPCP_LIBRARIES IPPCP::${_component})
         set(IPPCP_${_component}_FOUND 1)
     elseif (IPPCP_FIND_REQUIRED AND IPPCP_FIND_REQUIRED_${_component})
-        message(STATUS "Missed required Intel IPP Cryptography component: ${_component}")
+        message(STATUS "Missed required Intel Cryptography Primitives Library component: ${_component}")
         message(STATUS "  library not found:\n   ${PATH_TO_LIBRARY}")
         if (${LINKAGE_TYPE} MATCHES "SHARED")
             message(STATUS "You may try to search for static library by unsetting IPPCP_SHARED variable.")
diff --git a/sources/cmake/ippcp-utils.cmake b/sources/cmake/ippcp-utils.cmake
index 1af45bb..b2eb2df 100644
--- a/sources/cmake/ippcp-utils.cmake
+++ b/sources/cmake/ippcp-utils.cmake
@@ -23,20 +23,20 @@ macro(ippcp_getlibversion VERSION_FILE)
     unset(IPPCP_INTERFACE_VERSION_MINOR)
     file(STRINGS "${VERSION_FILE}" FILE_CONTENTS)
     foreach(LINE ${FILE_CONTENTS})
-        if ("${LINE}" MATCHES "#define IPP_VERSION_MAJOR")
-            string(REGEX REPLACE "^#define +IPP_VERSION_MAJOR +\([0-9]+\).*$" "\\1" IPPCP_VERSION_MAJOR ${LINE})
+        if ("${LINE}" MATCHES "#define CRYPTO_LIB_VERSION_MAJOR")
+            string(REGEX REPLACE "^#define +CRYPTO_LIB_VERSION_MAJOR +\([0-9]+\).*$" "\\1" IPPCP_VERSION_MAJOR ${LINE})
         endif()
-        if ("${LINE}" MATCHES "#define IPP_VERSION_MINOR")
-            string(REGEX REPLACE "^#define +IPP_VERSION_MINOR +\([0-9]+\).*$" "\\1" IPPCP_VERSION_MINOR ${LINE})
+        if ("${LINE}" MATCHES "#define CRYPTO_LIB_VERSION_MINOR")
+            string(REGEX REPLACE "^#define +CRYPTO_LIB_VERSION_MINOR +\([0-9]+\).*$" "\\1" IPPCP_VERSION_MINOR ${LINE})
         endif()
-        if ("${LINE}" MATCHES "#define IPP_VERSION_UPDATE")
-            string(REGEX REPLACE "^#define +IPP_VERSION_UPDATE +\([0-9]+\).*$" "\\1" IPPCP_VERSION_UPDATE ${LINE})
+        if ("${LINE}" MATCHES "#define CRYPTO_LIB_VERSION_PATCH")
+            string(REGEX REPLACE "^#define +CRYPTO_LIB_VERSION_PATCH +\([0-9]+\).*$" "\\1" IPPCP_VERSION_UPDATE ${LINE})
         endif()
-        if ("${LINE}" MATCHES "#define IPP_INTERFACE_VERSION_MAJOR")
-            string(REGEX REPLACE "^#define +IPP_INTERFACE_VERSION_MAJOR +\([0-9]+\).*$" "\\1" IPPCP_INTERFACE_VERSION_MAJOR ${LINE})
+        if ("${LINE}" MATCHES "#define CRYPTO_LIB_INTERFACE_VERSION_MAJOR")
+            string(REGEX REPLACE "^#define +CRYPTO_LIB_INTERFACE_VERSION_MAJOR +\([0-9]+\).*$" "\\1" IPPCP_INTERFACE_VERSION_MAJOR ${LINE})
         endif()
-        if ("${LINE}" MATCHES "#define IPP_INTERFACE_VERSION_MINOR")
-            string(REGEX REPLACE "^#define +IPP_INTERFACE_VERSION_MINOR +\([0-9]+\).*$" "\\1" IPPCP_INTERFACE_VERSION_MINOR ${LINE})
+        if ("${LINE}" MATCHES "#define CRYPTO_LIB_INTERFACE_VERSION_MINOR")
+            string(REGEX REPLACE "^#define +CRYPTO_LIB_INTERFACE_VERSION_MINOR +\([0-9]+\).*$" "\\1" IPPCP_INTERFACE_VERSION_MINOR ${LINE})
         endif()
     endforeach()
     set(IPPCP_VERSION "${IPPCP_VERSION_MAJOR}.${IPPCP_VERSION_MINOR}.${IPPCP_VERSION_UPDATE}")
diff --git a/sources/cmake/linux/Clang9.0.0.cmake b/sources/cmake/linux/Clang9.0.0.cmake
index 18e5182..4bb0746 100644
--- a/sources/cmake/linux/Clang9.0.0.cmake
+++ b/sources/cmake/linux/Clang9.0.0.cmake
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
 # Security Linker flags
@@ -77,9 +77,6 @@ endif()
 # Enable Intel® Control-Flow Enforcement Technology (Intel® CET) protection
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fcf-protection=full")
 
-# Security flag that adds compile-time and run-time checks
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_FORTIFY_SOURCE=2")
-
 if(NOT NONPIC_LIB)
   # Position Independent Execution (PIE)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fpic -fPIC")
@@ -106,7 +103,9 @@ if(SANITIZERS)
 endif(SANITIZERS)
 
 # Optimization level = 3, no-debug definition (turns off asserts), warnings=errors
-set (CMAKE_C_FLAGS_RELEASE " -O3 -DNDEBUG -Werror")
+set(CMAKE_C_FLAGS_RELEASE " -O3 -DNDEBUG -Werror")
+# Security flag that adds compile-time and run-time checks
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -D_FORTIFY_SOURCE=2")
 
 # DEBUG flags - optimization level = 0, generation GDB information (-g)
 set (CMAKE_C_FLAGS_DEBUG " -O0 -g")
diff --git a/sources/cmake/linux/GNU8.2.0.cmake b/sources/cmake/linux/GNU8.2.0.cmake
index 96658a8..55e60ae 100644
--- a/sources/cmake/linux/GNU8.2.0.cmake
+++ b/sources/cmake/linux/GNU8.2.0.cmake
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
 # Security Linker flags
@@ -51,7 +51,7 @@ set(CC_FLAGS_INLINE_ASM_UNIX_IA32 "${CC_FLAGS_INLINE_ASM_UNIX_IA32} -m32")
 # EBP is used as a general-purpose register in optimizations
 set(CC_FLAGS_INLINE_ASM_UNIX_IA32 "${CC_FLAGS_INLINE_ASM_UNIX_IA32} -fomit-frame-pointer")
 
-# Do not use the specified registres in dispatcher compilation
+# Do not use the specified registers in dispatcher compilation
 set(CC_FLAGS_INLINE_ASM_UNIX_INTEL64 "${CC_FLAGS_INLINE_ASM_UNIX} -ffixed-rdi -ffixed-rsi -ffixed-rbx -ffixed-rcx -ffixed-rdx -ffixed-rbp -ffixed-r8 -ffixed-r9 -ffixed-r12 -ffixed-r13 -ffixed-r14 -ffixed-r15")
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${LIBRARY_DEFINES}")
@@ -73,9 +73,6 @@ if ((${ARCH} MATCHES "ia32") OR (NOT NONPIC_LIB))
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector")
 endif()
 
-# Security flag that adds compile-time and run-time checks
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_FORTIFY_SOURCE=2")
-
 if(NOT NONPIC_LIB)
   # Position Independent Execution (PIE)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fpic -fPIC")
@@ -96,7 +93,9 @@ if(${ARCH} MATCHES "ia32")
 endif(${ARCH} MATCHES "ia32")
 
 # Optimization level = 3, no-debug definition (turns off asserts), warnings=errors
-set (CMAKE_C_FLAGS_RELEASE " -O3 -DNDEBUG -Werror")
+set(CMAKE_C_FLAGS_RELEASE " -O3 -DNDEBUG -Werror")
+# Security flag that adds compile-time and run-time checks
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -D_FORTIFY_SOURCE=2")
 
 set(w7_opt "${w7_opt} -march=pentium4 -msse2")
 set(s8_opt "${s8_opt} -march=core2 -mssse3")
diff --git a/sources/cmake/linux/Intel19.0.0.cmake b/sources/cmake/linux/Intel19.0.0.cmake
index c1d4850..8f0c3ae 100644
--- a/sources/cmake/linux/Intel19.0.0.cmake
+++ b/sources/cmake/linux/Intel19.0.0.cmake
@@ -15,13 +15,13 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
 # Linker flags
 
 # Security Linker flags
-set(LINK_FLAG_SECURITY "") 
+set(LINK_FLAG_SECURITY "")
 # Disallows undefined symbols in object files. Undefined symbols in shared libraries are still allowed
 set(LINK_FLAG_SECURITY "${LINK_FLAG_SECURITY} -Wl,-z,defs")
 # Stack execution protection
@@ -54,7 +54,7 @@ set(CC_FLAGS_INLINE_ASM_UNIX_IA32 "${CC_FLAGS_INLINE_ASM_UNIX_IA32} -m32")
 # EBP is used as a general-purpose register in optimizations
 set(CC_FLAGS_INLINE_ASM_UNIX_IA32 "${CC_FLAGS_INLINE_ASM_UNIX_IA32} -fomit-frame-pointer")
 
-# Do not use the specified registres in dispatcher compilation
+# Do not use the specified registers in dispatcher compilation
 set(CC_FLAGS_INLINE_ASM_UNIX_INTEL64 "${CC_FLAGS_INLINE_ASM_UNIX} -ffixed-rdi -ffixed-rsi -ffixed-rbx -ffixed-rcx -ffixed-rdx -ffixed-rbp -ffixed-r8 -ffixed-r9 -ffixed-r12 -ffixed-r13 -ffixed-r14 -ffixed-r15")
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${LIBRARY_DEFINES}")
@@ -77,9 +77,6 @@ if ((${ARCH} MATCHES "ia32") OR (NOT NONPIC_LIB))
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector")
 endif()
 
-# Security flag that adds compile-time and run-time checks
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_FORTIFY_SOURCE=2")
-
 # Format string vulnerabilities
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wformat -Wformat-security")
 
@@ -99,7 +96,10 @@ if(CODE_COVERAGE)
 endif()
 
 # Optimization level = 3, no-debug definition (turns off asserts), warning level = 3, treat warnings as errors
-set (CMAKE_C_FLAGS_RELEASE " -O3 -DNDEBUG -w3 -Werror")
+set(CMAKE_C_FLAGS_RELEASE " -O3 -DNDEBUG -w3 -Werror")
+# Security flag that adds compile-time and run-time checks
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -D_FORTIFY_SOURCE=2")
+
 # DEBUG flags Optimization level = 0, generation maximum GDB information (-g3)
 set (CMAKE_C_FLAGS_DEBUG " -O0 -g3")
 
diff --git a/sources/cmake/linux/IntelLLVM2023.1.0.cmake b/sources/cmake/linux/IntelLLVM2023.1.0.cmake
index babc289..2b26334 100644
--- a/sources/cmake/linux/IntelLLVM2023.1.0.cmake
+++ b/sources/cmake/linux/IntelLLVM2023.1.0.cmake
@@ -15,13 +15,13 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
 # Linker flags
 
 # Security Linker flags
-set(LINK_FLAG_SECURITY "") 
+set(LINK_FLAG_SECURITY "")
 # Disallows undefined symbols in object files. Undefined symbols in shared libraries are still allowed
 set(LINK_FLAG_SECURITY "${LINK_FLAG_SECURITY} -Wl,-z,defs")
 # Stack execution protection
@@ -54,7 +54,7 @@ set(CC_FLAGS_INLINE_ASM_UNIX_IA32 "${CC_FLAGS_INLINE_ASM_UNIX_IA32} -m32")
 # EBP is used as a general-purpose register in optimizations
 set(CC_FLAGS_INLINE_ASM_UNIX_IA32 "${CC_FLAGS_INLINE_ASM_UNIX_IA32} -fomit-frame-pointer")
 
-# Do not use the specified registres in dispatcher compilation
+# Do not use the specified registers in dispatcher compilation
 set(CC_FLAGS_INLINE_ASM_UNIX_INTEL64 "${CC_FLAGS_INLINE_ASM_UNIX} -ffixed-rdi -ffixed-rsi -ffixed-rbx -ffixed-rcx -ffixed-rdx -ffixed-rbp -ffixed-r8 -ffixed-r9 -ffixed-r12 -ffixed-r13 -ffixed-r14 -ffixed-r15")
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${LIBRARY_DEFINES}")
@@ -73,9 +73,6 @@ if ((${ARCH} MATCHES "ia32") OR (NOT NONPIC_LIB))
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector")
 endif()
 
-# Security flag that adds compile-time and run-time checks
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_FORTIFY_SOURCE=2")
-
 # Format string vulnerabilities
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wformat -Wformat-security -Wunknown-pragmas")
 
@@ -95,7 +92,9 @@ if(CODE_COVERAGE)
 endif()
 
 # Optimization level = 3, no-debug definition (turns off asserts), warning level = 3, treat warnings as errors
-set (CMAKE_C_FLAGS_RELEASE " -Ofast -DNDEBUG -Wall -Wno-unused-function -Wno-missing-braces -Werror")
+set(CMAKE_C_FLAGS_RELEASE " -Ofast -DNDEBUG -Wall -Wno-unused-function -Werror")
+# Security flag that adds compile-time and run-time checks
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -D_FORTIFY_SOURCE=2")
 
 # Alignment for structures on byte boundaries (= 16)
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Zp16")
@@ -104,13 +103,13 @@ if(${ARCH} MATCHES "ia32")
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -m32")
 endif(${ARCH} MATCHES "ia32")
 
-set(px_opt "${px_opt} -mia32")
-set(w7_opt "${w7_opt} -march=pentium4 -msse2")
+set(px_opt "${px_opt} ") # note: no flags for the default version
+set(w7_opt "${w7_opt} -msse2")
 set(s8_opt "${s8_opt} -march=core2 -mssse3")
 set(p8_opt "${p8_opt} -march=nehalem -msse4.2 -maes -mpclmul -msha")
 set(g9_opt "${g9_opt} -march=sandybridge -mavx -maes -mpclmul -msha -mrdrnd -mrdseed")
 set(h9_opt "${h9_opt} -march=haswell -mavx2 -maes -mvaes -mpclmul -mvpclmulqdq -msha -mrdrnd -mrdseed")
-set(mx_opt "${mx_opt} -march=pentium")
+set(mx_opt "${mx_opt} ") # note: no flags for the default version
 set(m7_opt "${m7_opt} -march=nocona -msse3")
 set(n8_opt "${n8_opt} -march=core2 -mssse3")
 set(y8_opt "${y8_opt} -march=nehalem -msse4.2 -maes -mpclmul -msha")
diff --git a/sources/cmake/linux/common.cmake b/sources/cmake/linux/common.cmake
index c0c5fd8..4b47261 100644
--- a/sources/cmake/linux/common.cmake
+++ b/sources/cmake/linux/common.cmake
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
 set(OS_DEFAULT_COMPILER Intel19.0.0)
diff --git a/sources/cmake/macosx/AppleClang11.0.0.cmake b/sources/cmake/macosx/AppleClang11.0.0.cmake
index 5f2ad63..2d5ec67 100644
--- a/sources/cmake/macosx/AppleClang11.0.0.cmake
+++ b/sources/cmake/macosx/AppleClang11.0.0.cmake
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
 # Security Linker flags
@@ -78,9 +78,6 @@ if ((${ARCH} MATCHES "ia32") OR (NOT NONPIC_LIB))
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector")
 endif()
 
-# Security flag that adds compile-time and run-time checks
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_FORTIFY_SOURCE=2")
-
 if(NOT NONPIC_LIB)
   # Position Independent Execution (PIE)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fpic -fPIC")
@@ -99,7 +96,9 @@ if(${ARCH} MATCHES "ia32")
 endif(${ARCH} MATCHES "ia32")
 
 # Optimization level = 3, no-debug definition (turns off asserts), warnings=errors
-set (CMAKE_C_FLAGS_RELEASE " -O3 -DNDEBUG -Werror")
+set(CMAKE_C_FLAGS_RELEASE " -O3 -DNDEBUG -Werror")
+# Security flag that adds compile-time and run-time checks
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -D_FORTIFY_SOURCE=2")
 
 set(w7_opt "${w7_opt} -march=pentium4 -msse2")
 set(s8_opt "${s8_opt} -march=core2 -mssse3")
diff --git a/sources/cmake/macosx/Intel19.0.0.cmake b/sources/cmake/macosx/Intel19.0.0.cmake
index b5456a1..bf1ea47 100644
--- a/sources/cmake/macosx/Intel19.0.0.cmake
+++ b/sources/cmake/macosx/Intel19.0.0.cmake
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
 # linker
@@ -47,7 +47,7 @@ set(CC_FLAGS_INLINE_ASM_UNIX_IA32 "${CC_FLAGS_INLINE_ASM_UNIX_IA32} -m32")
 # EBP is used as a general-purpose register in optimizations
 set(CC_FLAGS_INLINE_ASM_UNIX_IA32 "${CC_FLAGS_INLINE_ASM_UNIX_IA32} -fomit-frame-pointer")
 
-# Do not use the specified registres in dispatcher compilation
+# Do not use the specified registers in dispatcher compilation
 set(CC_FLAGS_INLINE_ASM_UNIX_INTEL64 "${CC_FLAGS_INLINE_ASM_UNIX} -ffixed-rdi -ffixed-rsi -ffixed-rbx -ffixed-rcx -ffixed-rdx -ffixed-rbp -ffixed-r8 -ffixed-r9 -ffixed-r12 -ffixed-r13 -ffixed-r14 -ffixed-r15")
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${LIBRARY_DEFINES}")
@@ -68,9 +68,6 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -diag-error 266 -diag-disable 13366
 # Stack-based Buffer Overrun Detection
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector")
 
-# Security flag that adds compile-time and run-time checks
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_FORTIFY_SOURCE=2")
-
 # Format string vulnerabilities
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wformat -Wformat-security")
 
@@ -86,7 +83,9 @@ if(CODE_COVERAGE)
 endif()
 
 # Optimization level = 3, no-debug definition (turns off asserts), warning level = 3, treat warnings as errors
-set (CMAKE_C_FLAGS_RELEASE " -O3 -DNDEBUG -w3 -Werror")
+set(CMAKE_C_FLAGS_RELEASE " -O3 -DNDEBUG -w3 -Werror")
+# Security flag that adds compile-time and run-time checks
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -D_FORTIFY_SOURCE=2")
 
 # Compile for x64
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -arch_only x86_64")
diff --git a/sources/cmake/macosx/common.cmake b/sources/cmake/macosx/common.cmake
index 874b01b..74e8b4b 100644
--- a/sources/cmake/macosx/common.cmake
+++ b/sources/cmake/macosx/common.cmake
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
 set(OS_DEFAULT_COMPILER Intel19.0.0)
diff --git a/sources/cmake/os_common.cmake b/sources/cmake/os_common.cmake
index 65f95ac..6379c94 100644
--- a/sources/cmake/os_common.cmake
+++ b/sources/cmake/os_common.cmake
@@ -15,10 +15,10 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
-# The ability to build custom Intel® IPP Cryptography library - enable specific CPU features at compile time
+# The ability to build custom Intel® Cryptography Primitives Library - enable specific CPU features at compile time
 if((NOT MERGED_BLD) AND (NOT "${IPPCP_CUSTOM_BUILD}" STREQUAL ""))
   set(LIBRARY_DEFINES "${LIBRARY_DEFINES} -DIPPCP_CUSTOM_BUILD")
   foreach(feature ${IPPCP_CUSTOM_BUILD})
diff --git a/sources/cmake/pkg-config/crypto_mb-dynamic.pc.in b/sources/cmake/pkg-config/crypto_mb-dynamic.pc.in
index 7b7b3d6..5ba9464 100644
--- a/sources/cmake/pkg-config/crypto_mb-dynamic.pc.in
+++ b/sources/cmake/pkg-config/crypto_mb-dynamic.pc.in
@@ -18,7 +18,7 @@ prefix=@PREFIX_FOR_PC_FILE@
 libdir=@LIBDIR_FOR_PC_FILE@
 includedir=@INCDIR_FOR_PC_FILE@
 
-Name: Intel® Integrated Performance Primitives (Intel® IPP) Cryptography Crypto Multi-Buffer Library
+Name: Intel® Cryptography Primitives Library Crypto Multi-Buffer Library
 Description: This library consists of highly-optimized kernels taking advantage of Intel’s multi-buffer processing and Intel® AVX-512 instruction set.
 URL: https://github.com/intel/ipp-crypto
 Version: @IPPCP_VERSION@
diff --git a/sources/cmake/pkg-config/crypto_mb-static.pc.in b/sources/cmake/pkg-config/crypto_mb-static.pc.in
index 3101b2f..2a99e34 100644
--- a/sources/cmake/pkg-config/crypto_mb-static.pc.in
+++ b/sources/cmake/pkg-config/crypto_mb-static.pc.in
@@ -18,7 +18,7 @@ prefix=@PREFIX_FOR_PC_FILE@
 libdir=@LIBDIR_FOR_PC_FILE@
 includedir=@INCDIR_FOR_PC_FILE@
 
-Name: Intel® Integrated Performance Primitives (Intel® IPP) Cryptography Crypto Multi-Buffer Library
+Name: Intel® Cryptography Primitives Library Crypto Multi-Buffer Library
 Description: This library consists of highly-optimized kernels taking advantage of Intel’s multi-buffer processing and Intel® AVX-512 instruction set.
 URL: https://github.com/intel/ipp-crypto
 Version: @IPPCP_VERSION@
diff --git a/sources/cmake/pkg-config/ippcp-dynamic.pc.in b/sources/cmake/pkg-config/ippcp-dynamic.pc.in
index 0067324..c154fdb 100644
--- a/sources/cmake/pkg-config/ippcp-dynamic.pc.in
+++ b/sources/cmake/pkg-config/ippcp-dynamic.pc.in
@@ -18,7 +18,7 @@ prefix=@PREFIX_FOR_PC_FILE@
 libdir=@LIBDIR_FOR_PC_FILE@
 includedir=@INCDIR_FOR_PC_FILE@
 
-Name: Intel® Integrated Performance Primitives (Intel® IPP) Cryptography Library
+Name: Intel® Cryptography Primitives Library
 Description: Secure, fast and lightweight library of building blocks for cryptography, highly-optimized for various Intel® CPUs.
 URL: https://github.com/intel/ipp-crypto
 Version: @IPPCP_VERSION@
diff --git a/sources/cmake/pkg-config/ippcp-static.pc.in b/sources/cmake/pkg-config/ippcp-static.pc.in
index 3cc69f4..b66e0e1 100644
--- a/sources/cmake/pkg-config/ippcp-static.pc.in
+++ b/sources/cmake/pkg-config/ippcp-static.pc.in
@@ -18,7 +18,7 @@ prefix=@PREFIX_FOR_PC_FILE@
 libdir=@LIBDIR_FOR_PC_FILE@
 includedir=@INCDIR_FOR_PC_FILE@
 
-Name: Intel® Integrated Performance Primitives (Intel® IPP) Cryptography Library
+Name: Intel® Cryptography Primitives Library
 Description: Secure, fast and lightweight library of building blocks for cryptography, highly-optimized for various Intel® CPUs.
 URL: https://github.com/intel/ipp-crypto
 Version: @IPPCP_VERSION@
diff --git a/sources/cmake/windows/Intel19.0.0.cmake b/sources/cmake/windows/Intel19.0.0.cmake
index cdfdbeb..87b03db 100644
--- a/sources/cmake/windows/Intel19.0.0.cmake
+++ b/sources/cmake/windows/Intel19.0.0.cmake
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
 # linker
@@ -36,11 +36,13 @@ if(${ARCH} MATCHES "ia32")
   # When /SAFESEH is specified, the linker will only produce an image if it can also produce a table of the image's safe exception handlers.
   set(LINK_FLAG_DYNAMIC_WINDOWS "${LINK_FLAG_DYNAMIC_WINDOWS} /SAFESEH")
 else()
-  # The /LARGEADDRESSAWARE option tells the linker that the application can handle addresses larger than 2 gigabytes. 
+  # The /LARGEADDRESSAWARE option tells the linker that the application can handle addresses larger than 2 gigabytes.
   set(LINK_FLAG_DYNAMIC_WINDOWS "${LINK_FLAG_DYNAMIC_WINDOWS} /LARGEADDRESSAWARE")
   # This option modifies the header of an executable image, a .dll file or .exe file, to indicate whether ASLR with 64-bit addresses is supported.
   set(LINK_FLAG_DYNAMIC_WINDOWS "${LINK_FLAG_DYNAMIC_WINDOWS} /HIGHENTROPYVA")
 endif(${ARCH} MATCHES "ia32")
+# Linker option to mitigate DLL hijacking vulnerability - removes CWD from the DLL search order
+set(LINK_FLAG_DYNAMIC_WINDOWS "${LINK_FLAG_DYNAMIC_WINDOWS} /DEPENDENTLOADFLAG:0x2000")
 
 # suppress warning LNK4221:
 # "This object file does not define any previously undefined public symbols, so it will not be used by any link operation that consumes this library"
@@ -93,8 +95,6 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Qsox-")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Gy")
 # C std
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Qstd=c99")
-# Security flag that adds compile-time and run-time checks
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /D_FORTIFY_SOURCE=2")
 # Enable Intel® Control-Flow Enforcement Technology (Intel® CET) protection
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Qcf-protection:full")
 
@@ -113,6 +113,8 @@ set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /DDEBUG")
 
 # Causes the application to use the multithread, static version of the run-time library.
 set(CMAKE_C_FLAGS_RELEASE "/MT")
+# Security flag that adds compile-time and run-time checks
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /D_FORTIFY_SOURCE=2")
 # Omits the default C runtime library name from the .obj file.
 set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /Zl")
 # "Maximize Speed". Selects a predefined set of options that affect the size and speed of generated code.
@@ -120,7 +122,7 @@ set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /O3") # /Ob2 is included in 
 # No-debug macro
 set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /DNDEBUG")
 
-# suppress warning #10120: overriding '/O2' with '/O3' 
+# suppress warning #10120: overriding '/O2' with '/O3'
 # CMake bug: cmake cannot change the property "Optimization" to /O3 in MSVC project
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -wd10120")
 
diff --git a/sources/cmake/windows/IntelLLVM2023.1.0.cmake b/sources/cmake/windows/IntelLLVM2023.1.0.cmake
index dd570ed..e8210d6 100644
--- a/sources/cmake/windows/IntelLLVM2023.1.0.cmake
+++ b/sources/cmake/windows/IntelLLVM2023.1.0.cmake
@@ -15,7 +15,7 @@
 #===============================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
 # linker
@@ -34,6 +34,8 @@ set(LINK_FLAG_DYNAMIC_WINDOWS "${LINK_FLAG_DYNAMIC_WINDOWS} /NXCOMPAT")
 set(LINK_FLAG_DYNAMIC_WINDOWS "${LINK_FLAG_DYNAMIC_WINDOWS} /DYNAMICBASE")
 # Enable Intel® Control-Flow Enforcement Technology (Intel® CET) protection
 set(LINK_FLAG_DYNAMIC_WINDOWS "${LINK_FLAG_DYNAMIC_WINDOWS} /CETCOMPAT")
+# Linker option to mitigate DLL hijacking vulnerability - removes CWD from the DLL search order
+set(LINK_FLAG_DYNAMIC_WINDOWS "${LINK_FLAG_DYNAMIC_WINDOWS} /DEPENDENTLOADFLAG:0x2000")
 
 if(${ARCH} MATCHES "ia32")
   # When /SAFESEH is specified, the linker will only produce an image if it can also produce a table of the image's safe exception handlers.
@@ -45,9 +47,6 @@ else()
   set(LINK_FLAG_DYNAMIC_WINDOWS "${LINK_FLAG_DYNAMIC_WINDOWS} /HIGHENTROPYVA")
 endif(${ARCH} MATCHES "ia32")
 
-# Disables linking to Intel® libraries
-set(LINK_FLAG_DYNAMIC_WINDOWS "${LINK_FLAG_DYNAMIC_WINDOWS} /Qno-intel-lib")
-
 # Link to universal C runtime and MSVC runtime. Used in dlls.
 set(LINK_LIB_STATIC_RELEASE libcmt libucrt libvcruntime)
 set(LINK_LIB_STATIC_DEBUG libcmtd libucrtd libvcruntime)
@@ -58,10 +57,10 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${LIBRARY_DEFINES}")
 # Suppresses the display of the copyright banner when the compiler starts up and display of informational messages during compiling.
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /nologo")
 # Warning level = 4
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4 -Wall -Wformat -Wformat-security -Werror=format-security")
 # Changes all warnings to errors.
 #set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /WX")
-# Detects some buffer overruns that overwrite a function's return address, exception handler address, or certain types of parameters. 
+# Detects some buffer overruns that overwrite a function's return address, exception handler address, or certain types of parameters.
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /GS")
 # Controls how the members of a structure are packed into memory and specifies the same packing for all structures in a module.
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Zp16")
@@ -72,7 +71,7 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Qstd=c99")
 # Enable Intel® Control-Flow Enforcement Technology (Intel® CET) protection
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fcf-protection:full")
 # Suppress some warnings
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Wno-missing-braces /Wno-null-pointer-arithmetic /Wno-unused-function /Wno-static-in-inline /Qno-intel-lib")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Wno-null-pointer-arithmetic /Wno-unused-function /Wno-static-in-inline /Qno-intel-lib")
 
 # Causes the application to use the multithread, static version of the run-time library (debug version).
 set(CMAKE_C_FLAGS_DEBUG "/MTd")
diff --git a/sources/cmake/windows/MSVC19.14.cmake b/sources/cmake/windows/MSVC19.14.cmake
index cee806f..fe19a9c 100644
--- a/sources/cmake/windows/MSVC19.14.cmake
+++ b/sources/cmake/windows/MSVC19.14.cmake
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
 # linker
@@ -43,6 +43,8 @@ else()
   # This option modifies the header of an executable image, a .dll file or .exe file, to indicate whether ASLR with 64-bit addresses is supported.
   set(LINK_FLAG_DYNAMIC_WINDOWS "${LINK_FLAG_DYNAMIC_WINDOWS} /HIGHENTROPYVA")
 endif(${ARCH} MATCHES "ia32")
+# Linker option to mitigate DLL hijacking vulnerability - removes CWD from the DLL search order
+set(LINK_FLAG_DYNAMIC_WINDOWS "${LINK_FLAG_DYNAMIC_WINDOWS} /DEPENDENTLOADFLAG:0x2000")
 
 if (MSVC_VERSION LESS_EQUAL 1800) # VS2013
   # Link to C runtime, used in dlls
@@ -65,7 +67,7 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /X")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4")
 # Changes all warnings to errors.
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /WX")
-# Detects some buffer overruns that overwrite a function's return address, exception handler address, or certain types of parameters. 
+# Detects some buffer overruns that overwrite a function's return address, exception handler address, or certain types of parameters.
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /GS")
 # Controls how the members of a structure are packed into memory and specifies the same packing for all structures in a module.
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Zp16")
diff --git a/sources/cmake/windows/common.cmake b/sources/cmake/windows/common.cmake
index baac529..ea8e282 100644
--- a/sources/cmake/windows/common.cmake
+++ b/sources/cmake/windows/common.cmake
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
 set(OS_DEFAULT_COMPILER Intel19.0.0)
diff --git a/sources/dispatcher/gen_disp_common.py b/sources/dispatcher/gen_disp_common.py
index 7950045..b99408a 100644
--- a/sources/dispatcher/gen_disp_common.py
+++ b/sources/dispatcher/gen_disp_common.py
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel(R) Integrated Performance Primitives Cryptography (Intel(R) IPP Cryptography)
+# Intel(R) Cryptography Primitives Library
 #
 
 import re
@@ -34,28 +34,28 @@ def readNextFunction(header, curLine, headerID):    ## read next function with a
       headerID= re.sub( '.*__IPP', '__IPP', header[curLine] )
       headerID= re.sub( "\)", '', headerID)
       headerID= re.sub( '[\n\s]', '', headerID )
-    
+
     if re.match( '^\s*IPPAPI\s*\(.*', header[curLine] ) :
       FunStr= header[curLine];
       FunStr= re.sub('\n','',FunStr)   ## remove EOL symbols
-  
+
       while not re.match('.*\)\s*\)\s*$', FunStr):   ## concatenate string if string is not completed
         curLine= curLine+1
         FunStr= FunStr+header[curLine]
         FunStr= re.sub('\n','',FunStr)   ## remove EOL symbols
-    
+
       FunStr= re.sub('\s+', ' ', FunStr)
-    
+
       s= FunStr.split(',')
-    
+
       ## Extract function name
       FunName= s[1]
       FunName= re.sub('\s', '', FunName)
-    
+
       ## Extract function type
       FunType= re.sub( '.*\(', '', s[0] )
       #FunType= re.sub(' ', '', FunType )
-    
+
       ## Extract function arguments
       FunArg= re.sub('.*\(.*,.+,\s*\(', '(', FunStr)
       FunArg= re.sub('\)\s*\)', ')', FunArg)
diff --git a/sources/dispatcher/gen_disp_lin32.nonpic.py b/sources/dispatcher/gen_disp_lin32.nonpic.py
index 457dceb..5e14c2c 100644
--- a/sources/dispatcher/gen_disp_lin32.nonpic.py
+++ b/sources/dispatcher/gen_disp_lin32.nonpic.py
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel(R) Integrated Performance Primitives Cryptography (Intel(R) IPP Cryptography)
+# Intel(R) Cryptography Primitives Library
 #
 
 import re
@@ -25,7 +25,7 @@ import hashlib
 import argparse
 
 parser = argparse.ArgumentParser()
-parser.add_argument('-i', '--header', action='store', required=True, help='Intel IPP Cryptography dispatcher will be generated for functions in Header')
+parser.add_argument('-i', '--header', action='store', required=True, help='Intel Cryptography Primitives Library dispatcher will be generated for functions in Header')
 parser.add_argument('-o', '--out-directory', action='store', required=True, help='Output folder for generated files')
 parser.add_argument('-l', '--cpu-list', action='store', required=True, help='Actual CPU list: semicolon separated string')
 parser.add_argument('-c', '--compiler', action='store', required=True, help='Compiler')
@@ -107,7 +107,7 @@ in_{FunName}:
 {FunName}:
     {endbr32}
     mov   eax, dword [ippcpJumpIndexForMergedLibs]
-    jmp   dword [rel arraddr_{FunName} + eax*4]
+    jmp   dword [arraddr_{FunName} + eax*4]
 .LEnd{FunName}:
 """.format(FunName=FunName, size=size, endbr32='db 0xf3, 0x0f, 0x1e, 0xfb'))
             ASMDISP.close()
diff --git a/sources/dispatcher/gen_disp_lin32.py b/sources/dispatcher/gen_disp_lin32.py
index ca0e34a..d75a32d 100644
--- a/sources/dispatcher/gen_disp_lin32.py
+++ b/sources/dispatcher/gen_disp_lin32.py
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel(R) Integrated Performance Primitives Cryptography (Intel(R) IPP Cryptography)
+# Intel(R) Cryptography Primitives Library
 #
 
 import re
@@ -25,7 +25,7 @@ import hashlib
 import argparse
 
 parser = argparse.ArgumentParser()
-parser.add_argument('-i', '--header', action='store', required=True, help='Intel IPP Cryptography dispatcher will be generated for functions in Header')
+parser.add_argument('-i', '--header', action='store', required=True, help='Intel Cryptography Primitives Library dispatcher will be generated for functions in Header')
 parser.add_argument('-o', '--out-directory', action='store', required=True, help='Output folder for generated files')
 parser.add_argument('-l', '--cpu-list', action='store', required=True, help='Actual CPU list: semicolon separated string')
 parser.add_argument('-c', '--compiler', action='store', required=True, help='Compiler')
diff --git a/sources/dispatcher/gen_disp_lin64.nonpic.py b/sources/dispatcher/gen_disp_lin64.nonpic.py
index 151390c..adfc3f1 100644
--- a/sources/dispatcher/gen_disp_lin64.nonpic.py
+++ b/sources/dispatcher/gen_disp_lin64.nonpic.py
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel(R) Integrated Performance Primitives Cryptography (Intel(R) IPP Cryptography)
+# Intel(R) Cryptography Primitives Library
 #
 
 import re
@@ -25,7 +25,7 @@ import hashlib
 import argparse
 
 parser = argparse.ArgumentParser()
-parser.add_argument('-i', '--header', action='store', required=True, help='Intel IPP Cryptography dispatcher will be generated for functions in Header')
+parser.add_argument('-i', '--header', action='store', required=True, help='Intel Cryptography Primitives Library dispatcher will be generated for functions in Header')
 parser.add_argument('-o', '--out-directory', action='store', required=True, help='Output folder for generated files')
 parser.add_argument('-l', '--cpu-list', action='store', required=True, help='Actual CPU list: semicolon separated string')
 parser.add_argument('-c', '--compiler', action='store', required=True, help='Compiler')
diff --git a/sources/dispatcher/gen_disp_lin64.py b/sources/dispatcher/gen_disp_lin64.py
index 787a604..0e6fa66 100644
--- a/sources/dispatcher/gen_disp_lin64.py
+++ b/sources/dispatcher/gen_disp_lin64.py
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel(R) Integrated Performance Primitives Cryptography (Intel(R) IPP Cryptography)
+# Intel(R) Cryptography Primitives Library
 #
 
 import re
@@ -25,7 +25,7 @@ import hashlib
 import argparse
 
 parser = argparse.ArgumentParser()
-parser.add_argument('-i', '--header', action='store', required=True, help='Intel IPP Cryptography dispatcher will be generated for functions in Header')
+parser.add_argument('-i', '--header', action='store', required=True, help='Intel Cryptography Primitives Library dispatcher will be generated for functions in Header')
 parser.add_argument('-o', '--out-directory', action='store', required=True, help='Output folder for generated files')
 parser.add_argument('-l', '--cpu-list', action='store', required=True, help='Actual CPU list: semicolon separated string')
 parser.add_argument('-c', '--compiler', action='store', required=True, help='Compiler')
@@ -75,6 +75,8 @@ if(compiler == "GNU" or compiler == "Clang"  or compiler == "IntelLLVM"):
             ##################################################
             ASMDISP= open( os.sep.join([OutDir, "jmp_" + FunName+"_" + hashlib.sha512(FunName.encode('utf-8')).hexdigest()[:8] +".asm"]), 'w' )
 
+            ASMDISP.write('%include "noexec_stack.inc"\n\n');
+
             # Symbol type setting for extern functions initially appeared in version 2.15
             ASMDISP.write("%if ((__NASM_MAJOR__ > 2) || ((__NASM_MAJOR__ == 2) && (__NASM_MINOR__ > 14)))\n");
             ASMDISP.write("  %xdefine elf_symbol_type :function\n");
diff --git a/sources/dispatcher/gen_disp_mac64.py b/sources/dispatcher/gen_disp_mac64.py
index f3851a7..72441b3 100644
--- a/sources/dispatcher/gen_disp_mac64.py
+++ b/sources/dispatcher/gen_disp_mac64.py
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel(R) Integrated Performance Primitives Cryptography (Intel(R) IPP Cryptography)
+# Intel(R) Cryptography Primitives Library
 #
 
 import re
@@ -25,7 +25,7 @@ import hashlib
 import argparse
 
 parser = argparse.ArgumentParser()
-parser.add_argument('-i', '--header', action='store', required=True, help='Intel IPP Cryptography dispatcher will be generated for functions in Header')
+parser.add_argument('-i', '--header', action='store', required=True, help='Intel Cryptography Primitives Library dispatcher will be generated for functions in Header')
 parser.add_argument('-o', '--out-directory', action='store', required=True, help='Output folder for generated files')
 parser.add_argument('-l', '--cpu-list', action='store', required=True, help='Actual CPU list: semicolon separated string')
 parser.add_argument('-c', '--compiler', action='store', help='Compiler') # is not used
@@ -111,13 +111,13 @@ else:
     while (isFunctionFound == True):
 
         result = readNextFunction(h, curLine, headerID)
-        
+
         curLine         = result['curLine']
         FunType         = result['FunType']
         FunName         = result['FunName']
         FunArg          = result['FunArg']
         isFunctionFound = result['success']
-        
+
         if (isFunctionFound == True):
 
             ##################################################
diff --git a/sources/dispatcher/gen_disp_win32.py b/sources/dispatcher/gen_disp_win32.py
index 1b615fc..9c3628b 100644
--- a/sources/dispatcher/gen_disp_win32.py
+++ b/sources/dispatcher/gen_disp_win32.py
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel(R) Integrated Performance Primitives Cryptography (Intel(R) IPP Cryptography)
+# Intel(R) Cryptography Primitives Library
 #
 
 import re
@@ -25,7 +25,7 @@ import hashlib
 import argparse
 
 parser = argparse.ArgumentParser()
-parser.add_argument('-i', '--header', action='store', required=True, help='Intel IPP Cryptography dispatcher will be generated for functions in Header')
+parser.add_argument('-i', '--header', action='store', required=True, help='Intel Cryptography Primitives Library dispatcher will be generated for functions in Header')
 parser.add_argument('-o', '--out-directory', action='store', required=True, help='Output folder for generated files')
 parser.add_argument('-l', '--cpu-list', action='store', required=True, help='Actual CPU list: semicolon separated string')
 parser.add_argument('-c', '--compiler', action='store', help='Compiler') # is not used
@@ -64,7 +64,7 @@ while (isFunctionFound == True):
   FunName         = result['FunName']
   FunArg          = result['FunArg']
   isFunctionFound = result['success']
-  
+
   if (isFunctionFound == True):
 
       ##################################################
@@ -82,7 +82,7 @@ while (isFunctionFound == True):
 
       for cpu in cpulist:
          DISP.write("extern " + FunType + " IPP_CALL "+cpu+"_"+FunName+FunArg+";\n")
- 
+
       DISP.write("static IPP_PROC arraddr[] =\n{{\n	(IPP_PROC)in_{}".format(FunName))
 
       for cpu in cpulist:
diff --git a/sources/dispatcher/gen_disp_win64.py b/sources/dispatcher/gen_disp_win64.py
index 1500460..681ca7e 100644
--- a/sources/dispatcher/gen_disp_win64.py
+++ b/sources/dispatcher/gen_disp_win64.py
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
 import re
@@ -25,7 +25,7 @@ import hashlib
 import argparse
 
 parser = argparse.ArgumentParser()
-parser.add_argument('-i', '--header', action='store', required=True, help='Intel IPP Cryptography dispatcher will be generated for functions in Header')
+parser.add_argument('-i', '--header', action='store', required=True, help='Intel Cryptography Primitives Library dispatcher will be generated for functions in Header')
 parser.add_argument('-o', '--out-directory', action='store', required=True, help='Output folder for generated files')
 parser.add_argument('-l', '--cpu-list', action='store', required=True, help='Actual CPU list: semicolon separated string')
 parser.add_argument('-c', '--compiler', action='store', help='Compiler') # is not used
@@ -56,34 +56,34 @@ FunArg = ""
 while (isFunctionFound == True):
 
   result = readNextFunction(h, curLine, headerID)
-  
+
   curLine         = result['curLine']
   FunName         = result['FunName']
   FunArg          = result['FunArg']
   isFunctionFound = result['success']
-  
+
   if (isFunctionFound == True):
     ##################################################
     ## create dispatcher files: C file with inline asm
     ##################################################
     filename = "jmp_{}_{}".format(FunName, hashlib.sha512(FunName.encode('utf-8')).hexdigest()[:8])
-    
+
     DISP= open( os.sep.join([OutDir, filename + ".asm"]), 'w' )
-    
+
     for cpu in cpulist:
        DISP.write("extern "+cpu+"_"+FunName+"\n")
-    
+
     DISP.write("extern ippcpJumpIndexForMergedLibs\n")
     DISP.write("extern ippcpSafeInit\n\n")
-    
+
     DISP.write("segment data\n\n")
-    
+
     DISP.write("    DQ in_"+FunName+"\n")
     DISP.write(FunName+"_arraddr:\n")
-    
+
     for cpu in cpulist:
        DISP.write("    DQ "+cpu+"_"+FunName+"\n")
-    
+
     DISP.write("""
 
 segment text
diff --git a/sources/gen_cpu_spc_header/gen_cpu_spc_1cpu_header.py b/sources/gen_cpu_spc_header/gen_cpu_spc_1cpu_header.py
index 3ac46ec..8a55cec 100644
--- a/sources/gen_cpu_spc_header/gen_cpu_spc_1cpu_header.py
+++ b/sources/gen_cpu_spc_header/gen_cpu_spc_1cpu_header.py
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel(R) Integrated Performance Primitives Cryptography (Intel(R) IPP Cryptography)
+# Intel(R) Cryptography Primitives Library
 #
 
 import sys
@@ -47,9 +47,16 @@ if not os.path.exists(OutDir):
 Filename="ippcp"
 Filenames=["h9", "p8", "s8", "w7", "e9", "k0", "k1", "l9", "m7", "n8", "y8", "g9"]
 
+DeprecatedCodePaths= {
+  "n8" : "m7", # SSSE3 -> SSE3 64-bit
+  "e9" : "y8", # AVX -> SSE4.2 64-bit
+  "s8" : "w7", # SSSE3 -> SSE2 32-bit
+  "g9" : "p8" # AVX -> SSE4.2 32-bit
+}
+
 for name in Filenames:
   OutFile  = os.sep.join([OutDir, Filename + "_"+ name + ".h"])
-  
+
   OUT= open( OutFile, 'w' )
   OUT.write("""/*******************************************************************************
   * Copyright {year} Intel Corporation
@@ -69,6 +76,15 @@ for name in Filenames:
 
   """.format(year=datetime.datetime.today().year))
 
+  if name in DeprecatedCodePaths:
+    OUT.write(f"""
+#if !defined(_NO_IPP_DEPRECATED)
+#pragma message (\"code path {name} is deprecated, lower optimizations level {DeprecatedCodePaths[name]} is used\")
+#endif
+""")
+    name = DeprecatedCodePaths[name]
+
+
   curLine = 0
   isFunctionFound = True
 
@@ -81,5 +97,5 @@ for name in Filenames:
     isFunctionFound = result['success']
 
     if (isFunctionFound):
-      OUT.write("#define " + FunName + " " + name +"_" + FunName + "\n")
+      OUT.write(f"#define {FunName} {name}_{FunName}\n")
   OUT.close()
diff --git a/sources/gen_cpu_spc_header/gen_cpu_spc_header.py b/sources/gen_cpu_spc_header/gen_cpu_spc_header.py
index 576deac..5e53f01 100644
--- a/sources/gen_cpu_spc_header/gen_cpu_spc_header.py
+++ b/sources/gen_cpu_spc_header/gen_cpu_spc_header.py
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel(R) Integrated Performance Primitives Cryptography (Intel(R) IPP Cryptography)
+# Intel(R) Cryptography Primitives Library
 #
 
 import sys
diff --git a/sources/include/asmdefs.inc b/sources/include/asmdefs.inc
index a469ffd..e35ad80 100644
--- a/sources/include/asmdefs.inc
+++ b/sources/include/asmdefs.inc
@@ -17,6 +17,8 @@
 %ifndef __ASMDEFS_INC__
 %define __ASMDEFS_INC__ 1
 
+%include "noexec_stack.inc"
+
 %assign _IPP_PX 0    ; pure C-code ia32
 %assign _IPP_M5 1    ; Intel(R) Quark(TM) processor - ia32
 %assign _IPP_W7 8    ; Intel(R) Streaming SIMD Extensions 2 - ia32
@@ -103,22 +105,6 @@
   %assign IPP_ALIGN_FACTOR 16
 %endif
 
-; noexec stack
-%ifdef LINUX32
-  %ifndef OSX32
-section .note.GNU-stack noalloc noexec nowrite progbits
-  %endif
-%endif
-
-; noexec stack
-%ifdef LINUX32E
-  %ifndef OSXEM64T
-    %ifndef _ARCH_KNC
-section .note.GNU-stack noalloc noexec nowrite progbits
-    %endif
-  %endif
-%endif
-
 
 %ifidn __OUTPUT_FORMAT__, elf32
   %assign IPP_BINARY_FORMAT 0
@@ -143,7 +129,7 @@ section .note.GNU-stack noalloc noexec nowrite progbits
 %ifndef _MERGED_BLD
   %assign _IPP_DATA 1
 %else
-  %if (_IPP == _IPP_G9) || (_IPP32E == _IPP32E_E9)
+  %if (_IPP == _IPP_P8) || (_IPP32E == _IPP32E_Y8)
     %assign _IPP_DATA 1
   %endif
 %endif ; _MERGED_BLD
diff --git a/sources/include/dispatcher.h b/sources/include/dispatcher.h
index fb6b190..40c7475 100644
--- a/sources/include/dispatcher.h
+++ b/sources/include/dispatcher.h
@@ -15,7 +15,7 @@
 *************************************************************************/
 
 //
-// Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+// Intel® Cryptography Primitives Library
 //
 
 #ifndef __DISPATCHER_H__
@@ -26,7 +26,7 @@ extern "C" {
 #endif
 
 /*
-  Intel IPP Cryptography libraries and CPU features mask fitness. Implemented only for IA32 and Intel64 (emt)
+  Intel® Cryptography Primitives Library and CPU features mask fitness. Implemented only for IA32 and Intel64 (emt)
 */
 
 #if defined( _ARCH_IA32 )
@@ -79,23 +79,23 @@ extern "C" {
 
 #if defined( _ARCH_IA32 ) && !defined( OSX32 )
   enum lib_enum {
-     LIB_W7=0, LIB_S8=1, LIB_P8=2, LIB_G9=3, LIB_H9=4, LIB_NOMORE
+     LIB_W7=0, LIB_P8=1, LIB_H9=2, LIB_NOMORE
   };
   #define LIB_PX LIB_W7
 #elif defined( OSX32 )
   enum lib_enum {
-     LIB_S8=0, LIB_P8=1, LIB_G9=2, LIB_H9=3, LIB_NOMORE
+     LIB_P8=0, LIB_H9=1, LIB_NOMORE
   };
   #define LIB_PX LIB_S8
   #define LIB_W7 LIB_S8
 #elif defined( _ARCH_EM64T ) && !defined( OSXEM64T )
   enum lib_enum {
-     LIB_M7=0, LIB_N8=1, LIB_Y8=2, LIB_E9=3, LIB_L9=4, LIB_K0=5, LIB_K1=6, LIB_NOMORE
+     LIB_M7=0, LIB_Y8=1, LIB_L9=2, LIB_K0=3, LIB_K1=4, LIB_NOMORE
   };
   #define LIB_PX LIB_M7
 #elif defined( OSXEM64T )
   enum lib_enum {
-     LIB_Y8=0, LIB_E9=1, LIB_L9=2, LIB_K0=3, LIB_K1=4, LIB_NOMORE
+     LIB_Y8=0, LIB_L9=1, LIB_K0=2, LIB_K1=3, LIB_NOMORE
   };
   #define LIB_PX LIB_Y8
   #define LIB_M7 LIB_Y8
@@ -178,34 +178,30 @@ extern "C" {
 #if defined( _ARCH_IA32 )
 
 /* Describe Intel CPUs and libraries */
-typedef enum{CPU_W7=0, CPU_S8, CPU_P8, CPU_G9, CPU_H9, CPU_NOMORE} cpu_enum;
-typedef enum{DLL_W7=0, DLL_S8, DLL_P8, DLL_G9, DLL_H9, DLL_NOMORE} dll_enum;
+typedef enum{CPU_W7=0, CPU_P8, CPU_H9, CPU_NOMORE} cpu_enum;
+typedef enum{DLL_W7=0, DLL_P8, DLL_H9, DLL_NOMORE} dll_enum;
 
 /* New cpu can use some libraries for old cpu */
 static const dll_enum dllUsage[][DLL_NOMORE+1] = {
-         /*  DLL_H9, DLL_G9, DLL_P8, DLL_S8, DLL_W7, DLL_NOMORE */
-/*CPU_W7*/ {                                 DLL_W7, DLL_NOMORE },
-/*CPU_S8*/ {                         DLL_S8, DLL_W7, DLL_NOMORE },
-/*CPU_P8*/ {                 DLL_P8, DLL_S8, DLL_W7, DLL_NOMORE },
-/*CPU_G9*/ {         DLL_G9, DLL_P8, DLL_S8, DLL_W7, DLL_NOMORE },
-/*CPU_H9*/ { DLL_H9, DLL_G9, DLL_P8, DLL_S8, DLL_W7, DLL_NOMORE }
+         /*  DLL_H9, DLL_P8, DLL_W7, DLL_NOMORE */
+/*CPU_W7*/ {                 DLL_W7, DLL_NOMORE },
+/*CPU_P8*/ {         DLL_P8, DLL_W7, DLL_NOMORE },
+/*CPU_H9*/ { DLL_H9, DLL_P8, DLL_W7, DLL_NOMORE }
 };
 
 #elif defined (_ARCH_EM64T)
 /* Describe Intel CPUs and libraries */
-typedef enum{CPU_M7=0, CPU_N8, CPU_Y8, CPU_E9, CPU_L9, CPU_K0, CPU_K1, CPU_NOMORE} cpu_enum;
-typedef enum{DLL_M7=0, DLL_N8, DLL_Y8, DLL_E9, DLL_L9, DLL_K0, DLL_K1, DLL_NOMORE} dll_enum;
+typedef enum{CPU_M7=0, CPU_Y8, CPU_L9, CPU_K0, CPU_K1, CPU_NOMORE} cpu_enum;
+typedef enum{DLL_M7=0, DLL_Y8, DLL_L9, DLL_K0, DLL_K1, DLL_NOMORE} dll_enum;
 
 /* New cpu can use some libraries for old cpu */
 static const dll_enum dllUsage[][DLL_NOMORE+1] = {
-         /*  DLL_K1, DLL_K0, DLL_L9, DLL_E9, DLL_Y8, DLL_N8, DLL_M7, DLL_NOMORE */
-/*CPU_M7*/ {                                                  DLL_M7, DLL_NOMORE },
-/*CPU_N8*/ {                                          DLL_N8, DLL_M7, DLL_NOMORE },
-/*CPU_Y8*/ {                                  DLL_Y8, DLL_N8, DLL_M7, DLL_NOMORE },
-/*CPU_E9*/ {                          DLL_E9, DLL_Y8, DLL_N8, DLL_M7, DLL_NOMORE },
-/*CPU_L9*/ {                  DLL_L9, DLL_E9, DLL_Y8, DLL_N8, DLL_M7, DLL_NOMORE },
-/*CPU_K0*/ {         DLL_K0,  DLL_L9, DLL_E9, DLL_Y8, DLL_N8, DLL_M7, DLL_NOMORE },
-/*CPU_K1*/ { DLL_K1, DLL_K0,  DLL_L9, DLL_E9, DLL_Y8, DLL_N8, DLL_M7, DLL_NOMORE }
+/*           DLL_K1, DLL_K0, DLL_L9, DLL_Y8, DLL_M7, DLL_NOMORE */
+/*CPU_M7*/ {                                  DLL_M7, DLL_NOMORE },
+/*CPU_Y8*/ {                          DLL_Y8, DLL_M7, DLL_NOMORE },
+/*CPU_L9*/ {                  DLL_L9, DLL_Y8, DLL_M7, DLL_NOMORE },
+/*CPU_K0*/ {         DLL_K0,  DLL_L9, DLL_Y8, DLL_M7, DLL_NOMORE },
+/*CPU_K1*/ { DLL_K1, DLL_K0,  DLL_L9, DLL_Y8, DLL_M7, DLL_NOMORE }
 };
 
 #endif
@@ -216,41 +212,31 @@ static const dll_enum dllUsage[][DLL_NOMORE+1] = {
 #if defined ( WIN32 )
 static const _TCHAR* dllNames[DLL_NOMORE] = {
     _T(IPP_LIB_PREFIX()) _T("w7") _T(".dll"),
-    _T(IPP_LIB_PREFIX()) _T("s8") _T(".dll"),
     _T(IPP_LIB_PREFIX()) _T("p8") _T(".dll"),
-    _T(IPP_LIB_PREFIX()) _T("g9") _T(".dll"),
     _T(IPP_LIB_PREFIX()) _T("h9") _T(".dll")
 };
 #elif defined(LINUX32)
 static const _TCHAR* dllNames[DLL_NOMORE] = {
     _T("lib") _T(IPP_LIB_PREFIX()) _T("w7.so"),
-    _T("lib") _T(IPP_LIB_PREFIX()) _T("s8.so"),
     _T("lib") _T(IPP_LIB_PREFIX()) _T("p8.so"),
-    _T("lib") _T(IPP_LIB_PREFIX()) _T("g9.so"),
     _T("lib") _T(IPP_LIB_PREFIX()) _T("h9.so")
 };
 #elif defined( OSX32 )
 static const _TCHAR* dllNames[DLL_NOMORE] = {
-    _T("lib") _T(IPP_LIB_PREFIX()) _T("s8") _T(".dylib"),
     _T("lib") _T(IPP_LIB_PREFIX()) _T("p8") _T(".dylib"),
-    _T("lib") _T(IPP_LIB_PREFIX()) _T("g9") _T(".dylib"),
     _T("lib") _T(IPP_LIB_PREFIX()) _T("h9") _T(".dylib")
 };
 #elif defined( WIN32E )
 static const _TCHAR* dllNames[DLL_NOMORE] = {
     _T(IPP_LIB_PREFIX()) _T("m7") _T(".dll"),
-    _T(IPP_LIB_PREFIX()) _T("n8") _T(".dll"),
     _T(IPP_LIB_PREFIX()) _T("y8") _T(".dll"),
-    _T(IPP_LIB_PREFIX()) _T("e9") _T(".dll"),
     _T(IPP_LIB_PREFIX()) _T("l9") _T(".dll"),
     _T(IPP_LIB_PREFIX()) _T("k0") _T(".dll"),
     _T(IPP_LIB_PREFIX()) _T("k1") _T(".dll")
 };
 #elif defined( OSXEM64T )
 static const _TCHAR* dllNames[DLL_NOMORE] = {
-    _T("lib") _T(IPP_LIB_PREFIX()) _T("n8") _T(".dylib"),
     _T("lib") _T(IPP_LIB_PREFIX()) _T("y8") _T(".dylib"),
-    _T("lib") _T(IPP_LIB_PREFIX()) _T("e9") _T(".dylib"),
     _T("lib") _T(IPP_LIB_PREFIX()) _T("l9") _T(".dylib"),
     _T("lib") _T(IPP_LIB_PREFIX()) _T("k0") _T(".dylib"),
     _T("lib") _T(IPP_LIB_PREFIX()) _T("k1") _T(".dylib")
@@ -258,9 +244,7 @@ static const _TCHAR* dllNames[DLL_NOMORE] = {
 #elif defined( LINUX32E )
 static const _TCHAR* dllNames[DLL_NOMORE] = {
     _T("lib") _T(IPP_LIB_PREFIX()) _T("m7.so"),
-    _T("lib") _T(IPP_LIB_PREFIX()) _T("n8.so"),
     _T("lib") _T(IPP_LIB_PREFIX()) _T("y8.so"),
-    _T("lib") _T(IPP_LIB_PREFIX()) _T("e9.so"),
     _T("lib") _T(IPP_LIB_PREFIX()) _T("l9.so"),
     _T("lib") _T(IPP_LIB_PREFIX()) _T("k0.so"),
     _T("lib") _T(IPP_LIB_PREFIX()) _T("k1.so")
diff --git a/sources/include/fips_cert_internal/bn_common.h b/sources/include/fips_cert_internal/bn_common.h
index 6a36dfa..a2e8dc6 100644
--- a/sources/include/fips_cert_internal/bn_common.h
+++ b/sources/include/fips_cert_internal/bn_common.h
@@ -31,9 +31,9 @@
  * \param[in] sgn sign of big number
  * \param[in] pdata pointer to integer big number
  * \param[in] data_word_len length of integer big number in 32bit size
- * 
+ *
  */
-__INLINE IppStatus ippcp_init_set_bn(IppsBigNumState *pbn, int max_word_len,
+__IPPCP_INLINE IppStatus ippcp_init_set_bn(IppsBigNumState *pbn, int max_word_len,
                                      IppsBigNumSGN sgn, const Ipp32u *pdata, int data_word_len)
 {
   IppStatus sts;
diff --git a/sources/include/ippres.gen b/sources/include/ippres.gen
index 3ba4092..2da801b 100644
--- a/sources/include/ippres.gen
+++ b/sources/include/ippres.gen
@@ -43,101 +43,101 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "Intel Corporation.\0"
             VALUE "FileVersion", STR_FILE_VERSION() "\0"
-            VALUE "ProductName", IPP_LIB_SHORTNAME() ". Intel(R) Integrated Performance Primitives. " IPP_LIB_LONGNAME() ".\0"
+            VALUE "ProductName", CRYPTO_LIB_NAME() ".\0"
             VALUE "ProductVersion", STR_VERSION() "\0"
             VALUE "LegalCopyright", "Copyright (C) 1999-2021, Intel Corporation. All rights reserved.\0"
-         
+
             #if defined(_MERGED_BLD)
                 #if defined (WIN32) && !defined (_WIN64) && !defined (WIN32E)
-                    VALUE "Comments", "Intel(R) Integrated Performance Primitives. " IPP_LIB_LONGNAME() ".\0"
-                    VALUE "FileDescription", IPP_LIB_PREFIX() _IPP_VERSION ".dll is the ia32 " IPP_LIB_SHORTNAME() " dynamic library\0"
+                    VALUE "Comments", "Intel(R) Cryptography Primitives Library. " ".\0"
+                    VALUE "FileDescription", IPP_LIB_PREFIX() _IPP_VERSION ".dll is the ia32 " CRYPTO_LIB_NAME() " dynamic library\0"
                     VALUE "InternalName", IPP_LIB_PREFIX() _IPP_VERSION ".dll\0"
                     VALUE "OriginalFilename", IPP_LIB_PREFIX() _IPP_VERSION ".dll\0"
                 #endif
 
                 #if defined(WIN32E)
-                    VALUE "Comments", "Intel(R) Integrated Performance Primitives. " IPP_LIB_LONGNAME() ".\0"
-                    VALUE "FileDescription", IPP_LIB_PREFIX() _IPP_VERSION ".dll is the intel64 " IPP_LIB_SHORTNAME() " dynamic library\0"
+                    VALUE "Comments", CRYPTO_LIB_NAME() ".\0"
+                    VALUE "FileDescription", IPP_LIB_PREFIX() _IPP_VERSION ".dll is the intel64 " CRYPTO_LIB_NAME() " dynamic library\0"
                     VALUE "InternalName", IPP_LIB_PREFIX() _IPP_VERSION ".dll\0"
                     VALUE "OriginalFilename", IPP_LIB_PREFIX() _IPP_VERSION ".dll\0"
                 #endif
-         
+
             #else
                 #if defined (_PX) && defined (WIN32) && !defined (_WIN64) && !defined (WIN32E)
-                    VALUE "Comments", "Intel(R) Integrated Performance Primitives. " IPP_LIB_LONGNAME() ". For Intel(R) Pentium(R) processors\0"
-                    VALUE "FileDescription", IPP_LIB_PREFIX() "px" _IPP_VERSION  ".dll is an " IPP_LIB_SHORTNAME() " dynamic library\0"
+                    VALUE "Comments", CRYPTO_LIB_NAME() ". For Intel(R) Pentium(R) processors\0"
+                    VALUE "FileDescription", IPP_LIB_PREFIX() "px" _IPP_VERSION  ".dll is an " CRYPTO_LIB_NAME() " dynamic library\0"
                     VALUE "InternalName", IPP_LIB_PREFIX() "px" _IPP_VERSION  ".dll\0"
                     VALUE "OriginalFilename", IPP_LIB_PREFIX() "px" _IPP_VERSION  ".dll\0"
                 #endif
                 #if defined(_PX) && defined(WIN32E)
-                    VALUE "Comments", "Intel(R) Integrated Performance Primitives. " IPP_LIB_LONGNAME() ". For Intel(R) 64 Instruction Set Architecture (ISA) processors\0"
-                    VALUE "FileDescription", IPP_LIB_PREFIX() "mx" _IPP_VERSION  ".dll is an " IPP_LIB_SHORTNAME() " dynamic library\0"
+                    VALUE "Comments", CRYPTO_LIB_NAME() ". For Intel(R) 64 Instruction Set Architecture (ISA) processors\0"
+                    VALUE "FileDescription", IPP_LIB_PREFIX() "mx" _IPP_VERSION  ".dll is an " CRYPTO_LIB_NAME() " dynamic library\0"
                     VALUE "InternalName", IPP_LIB_PREFIX() "mx" _IPP_VERSION  ".dll\0"
                     VALUE "OriginalFilename", IPP_LIB_PREFIX() "mx" _IPP_VERSION  ".dll\0"
                 #endif
                 #if defined(_W7)
-                    VALUE "Comments", "Intel(R) Integrated Performance Primitives. " IPP_LIB_LONGNAME() ". Optimized for processors with Streaming SIMD Extensions 2 (SSE2)\0"
-                    VALUE "FileDescription", IPP_LIB_PREFIX() "w7" _IPP_VERSION  ".dll is an " IPP_LIB_SHORTNAME() " dynamic library\0"
+                    VALUE "Comments", CRYPTO_LIB_NAME() ". Optimized for processors with Streaming SIMD Extensions 2 (SSE2)\0"
+                    VALUE "FileDescription", IPP_LIB_PREFIX() "w7" _IPP_VERSION  ".dll is an " CRYPTO_LIB_NAME() " dynamic library\0"
                     VALUE "InternalName", IPP_LIB_PREFIX() "w7" _IPP_VERSION  ".dll\0"
                     VALUE "OriginalFilename", IPP_LIB_PREFIX() "w7" _IPP_VERSION  ".dll\0"
                 #endif
                 #if defined(_P8)
-                    VALUE "Comments", "Intel(R) Integrated Performance Primitives. " IPP_LIB_LONGNAME() ". Optimized for processors with Streaming SIMD Extensions 4.2 (SSE4.2)\0"
-                    VALUE "FileDescription", IPP_LIB_PREFIX() "p8" _IPP_VERSION  ".dll is an " IPP_LIB_SHORTNAME() " dynamic library\0"
+                    VALUE "Comments", CRYPTO_LIB_NAME() ". Optimized for processors with Streaming SIMD Extensions 4.2 (SSE4.2)\0"
+                    VALUE "FileDescription", IPP_LIB_PREFIX() "p8" _IPP_VERSION  ".dll is an " CRYPTO_LIB_NAME() " dynamic library\0"
                     VALUE "InternalName", IPP_LIB_PREFIX() "p8" _IPP_VERSION  ".dll\0"
                     VALUE "OriginalFilename", IPP_LIB_PREFIX() "p8" _IPP_VERSION  ".dll\0"
                 #endif
                 #if defined(_G9)
-                    VALUE "Comments", "Intel(R) Integrated Performance Primitives. " IPP_LIB_LONGNAME() ". Optimized for processors with Advanced Vector Extensions (AVX)\0"
-                    VALUE "FileDescription", IPP_LIB_PREFIX() "g9" _IPP_VERSION  ".dll is an " IPP_LIB_SHORTNAME() " dynamic library\0"
+                    VALUE "Comments", CRYPTO_LIB_NAME() ". Optimized for processors with Advanced Vector Extensions (AVX)\0"
+                    VALUE "FileDescription", IPP_LIB_PREFIX() "g9" _IPP_VERSION  ".dll is an " CRYPTO_LIB_NAME() " dynamic library\0"
                     VALUE "InternalName", IPP_LIB_PREFIX() "g9" _IPP_VERSION  ".dll\0"
                     VALUE "OriginalFilename", IPP_LIB_PREFIX() "g9" _IPP_VERSION  ".dll\0"
                 #endif
                 #if defined(_H9)
-                    VALUE "Comments", "Intel(R) Integrated Performance Primitives. " IPP_LIB_LONGNAME() ". Optimized for processors with Advanced Vector Extensions 2 (AVX2)\0"
-                    VALUE "FileDescription", IPP_LIB_PREFIX() "h9" _IPP_VERSION  ".dll is an " IPP_LIB_SHORTNAME() " dynamic library\0"
+                    VALUE "Comments", CRYPTO_LIB_NAME() ". Optimized for processors with Advanced Vector Extensions 2 (AVX2)\0"
+                    VALUE "FileDescription", IPP_LIB_PREFIX() "h9" _IPP_VERSION  ".dll is an " CRYPTO_LIB_NAME() " dynamic library\0"
                     VALUE "InternalName", IPP_LIB_PREFIX() "h9" _IPP_VERSION  ".dll\0"
                     VALUE "OriginalFilename", IPP_LIB_PREFIX() "h9" _IPP_VERSION  ".dll\0"
                 #endif
                 #if defined(_M7)
-                    VALUE "Comments", "Intel(R) Integrated Performance Primitives. " IPP_LIB_LONGNAME() ". Optimized for Intel(R) 64 Instruction Set Architecture (ISA)\0"
-                    VALUE "FileDescription", IPP_LIB_PREFIX() "m7" _IPP_VERSION  ".dll is an " IPP_LIB_SHORTNAME() " dynamic library\0"
+                    VALUE "Comments", CRYPTO_LIB_NAME() ". Optimized for Intel(R) 64 Instruction Set Architecture (ISA)\0"
+                    VALUE "FileDescription", IPP_LIB_PREFIX() "m7" _IPP_VERSION  ".dll is an " CRYPTO_LIB_NAME() " dynamic library\0"
                     VALUE "InternalName", IPP_LIB_PREFIX() "m7" _IPP_VERSION  ".dll\0"
                     VALUE "OriginalFilename", IPP_LIB_PREFIX() "m7" _IPP_VERSION  ".dll\0"
                 #endif
                 #if defined(_Y8)
-                    VALUE "Comments", "Intel(R) Integrated Performance Primitives. " IPP_LIB_LONGNAME() ". Optimized for processors with Streaming SIMD Extensions 4.2 (SSE4.2)\0"
-                    VALUE "FileDescription", IPP_LIB_PREFIX() "y8" _IPP_VERSION  ".dll is an " IPP_LIB_SHORTNAME() " dynamic library\0"
+                    VALUE "Comments", CRYPTO_LIB_NAME()  ". Optimized for processors with Streaming SIMD Extensions 4.2 (SSE4.2)\0"
+                    VALUE "FileDescription", IPP_LIB_PREFIX() "y8" _IPP_VERSION  ".dll is an " CRYPTO_LIB_NAME() " dynamic library\0"
                     VALUE "InternalName", IPP_LIB_PREFIX() "y8" _IPP_VERSION  ".dll\0"
                     VALUE "OriginalFilename", IPP_LIB_PREFIX() "y8" _IPP_VERSION  ".dll\0"
                 #endif
                 #if defined(_E9)
-                    VALUE "Comments", "Intel(R) Integrated Performance Primitives. " IPP_LIB_LONGNAME() ". Optimized for processors with Advanced Vector Extensions (AVX)\0"
-                    VALUE "FileDescription", IPP_LIB_PREFIX() "e9" _IPP_VERSION  ".dll is an " IPP_LIB_SHORTNAME() " dynamic library\0"
+                    VALUE "Comments", CRYPTO_LIB_NAME() ". Optimized for processors with Advanced Vector Extensions (AVX)\0"
+                    VALUE "FileDescription", IPP_LIB_PREFIX() "e9" _IPP_VERSION  ".dll is an " CRYPTO_LIB_NAME() " dynamic library\0"
                     VALUE "InternalName", IPP_LIB_PREFIX() "e9" _IPP_VERSION  ".dll\0"
                     VALUE "OriginalFilename", IPP_LIB_PREFIX() "e9" _IPP_VERSION  ".dll\0"
                 #endif
                 #if defined(_L9)
-                    VALUE "Comments", "Intel(R) Integrated Performance Primitives. " IPP_LIB_LONGNAME() ". Optimized for processors with Advanced Vector Extensions 2 (AVX2)\0"
-                    VALUE "FileDescription", IPP_LIB_PREFIX() "l9" _IPP_VERSION  ".dll is an " IPP_LIB_SHORTNAME() " dynamic library\0"
+                    VALUE "Comments", CRYPTO_LIB_NAME() ". Optimized for processors with Advanced Vector Extensions 2 (AVX2)\0"
+                    VALUE "FileDescription", IPP_LIB_PREFIX() "l9" _IPP_VERSION  ".dll is an " CRYPTO_LIB_NAME() " dynamic library\0"
                     VALUE "InternalName", IPP_LIB_PREFIX() "l9" _IPP_VERSION  ".dll\0"
                     VALUE "OriginalFilename", IPP_LIB_PREFIX() "l9" _IPP_VERSION  ".dll\0"
                 #endif
                 #if defined(_K0)
-                    VALUE "Comments", "Intel(R) Integrated Performance Primitives. " IPP_LIB_LONGNAME() ". Optimized for processors with AVX512F/CD/BW/DQ/VL support\0"
-                    VALUE "FileDescription", IPP_LIB_PREFIX() "k0" _IPP_VERSION  ".dll is an " IPP_LIB_SHORTNAME() " dynamic library\0"
+                    VALUE "Comments", CRYPTO_LIB_NAME() ". Optimized for processors with AVX512F/CD/BW/DQ/VL support\0"
+                    VALUE "FileDescription", IPP_LIB_PREFIX() "k0" _IPP_VERSION  ".dll is an " CRYPTO_LIB_NAME() " dynamic library\0"
                     VALUE "InternalName", IPP_LIB_PREFIX() "k0" _IPP_VERSION  ".dll\0"
                     VALUE "OriginalFilename", IPP_LIB_PREFIX() "k0" _IPP_VERSION  ".dll\0"
                 #endif
                 #if defined(_S8)
-                    VALUE "Comments", "Intel(R) Integrated Performance Primitives. " IPP_LIB_LONGNAME() ". Optimized for Intel(R) Atom(TM) processor\0"
-                    VALUE "FileDescription", IPP_LIB_PREFIX() "s8" _IPP_VERSION  ".dll is an " IPP_LIB_SHORTNAME() " dynamic library\0"
+                    VALUE "Comments", CRYPTO_LIB_NAME() ". Optimized for Intel(R) Atom(TM) processor\0"
+                    VALUE "FileDescription", IPP_LIB_PREFIX() "s8" _IPP_VERSION  ".dll is an " CRYPTO_LIB_NAME() " dynamic library\0"
                     VALUE "InternalName", IPP_LIB_PREFIX() "s8" _IPP_VERSION  ".dll\0"
                     VALUE "OriginalFilename", IPP_LIB_PREFIX() "s8" _IPP_VERSION  ".dll\0"
                 #endif
                 #if defined(_N8)
-                    VALUE "Comments", "Intel(R) Integrated Performance Primitives. " IPP_LIB_LONGNAME() ". Optimized for Intel(R) Atom(TM) processor\0"
-                    VALUE "FileDescription", IPP_LIB_PREFIX() "n8" _IPP_VERSION  ".dll is an " IPP_LIB_SHORTNAME() " dynamic library\0"
+                    VALUE "Comments", CRYPTO_LIB_NAME() ". Optimized for Intel(R) Atom(TM) processor\0"
+                    VALUE "FileDescription", IPP_LIB_PREFIX() "n8" _IPP_VERSION  ".dll is an " CRYPTO_LIB_NAME() " dynamic library\0"
                     VALUE "InternalName", IPP_LIB_PREFIX() "n8" _IPP_VERSION  ".dll\0"
                     VALUE "OriginalFilename", IPP_LIB_PREFIX() "n8" _IPP_VERSION  ".dll\0"
                 #endif
diff --git a/sources/include/ippver.h b/sources/include/ippver.h
index 52d1a27..ee04705 100644
--- a/sources/include/ippver.h
+++ b/sources/include/ippver.h
@@ -15,30 +15,30 @@
 *************************************************************************/
 
 /*
-//              Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+//              Intel® Cryptography Primitives Library
 //
-//              Purpose: Describes the base Intel IPP Cryptography version
+//              Purpose: Describes the base Intel® Cryptography Primitives Library version
 //
 */
 
 
-#include "ippversion.h"
+#include "ippcpversion.h"
 #ifndef BASE_VERSION
-#define BASE_VERSION() IPP_VERSION_MAJOR,IPP_VERSION_MINOR,IPP_VERSION_UPDATE
+#define BASE_VERSION() CRYPTO_LIB_VERSION_MAJOR,CRYPTO_LIB_VERSION_MINOR,CRYPTO_LIB_VERSION_PATCH
 #endif
 
 #define STR2(x)           #x
 #define STR(x)       STR2(x)
 
 #ifndef STR_BASE_VERSION
-#define STR_BASE_VERSION() STR(IPP_VERSION_MAJOR) "," STR(IPP_VERSION_MINOR) ", " STR(IPP_VERSION_UPDATE)
+#define STR_BASE_VERSION() STR(CRYPTO_LIB_VERSION_MAJOR) "," STR(CRYPTO_LIB_VERSION_MINOR) ", " STR(CRYPTO_LIB_VERSION_PATCH)
 #endif
 
 #ifndef STR_VERSION
  #ifdef IPP_REVISION
-  #define STR_VERSION() IPP_VERSION_STR " (r" STR( IPP_REVISION ) ")"
+  #define STR_VERSION() CRYPTO_LIB_VERSION_STR " (r" STR( IPP_REVISION ) ")"
  #else
-  #define STR_VERSION() IPP_VERSION_STR " (-)"
+  #define STR_VERSION() CRYPTO_LIB_VERSION_STR
  #endif
 #endif
 
diff --git a/sources/include/lms_internal/lmots.h b/sources/include/lms_internal/lmots.h
index b9ae5a4..bb3f480 100644
--- a/sources/include/lms_internal/lmots.h
+++ b/sources/include/lms_internal/lmots.h
@@ -58,7 +58,7 @@ typedef struct {
  * Output parameters:
  *    params         LMOTS parameters (w, p, ls, n, hash_method)
  */
-__INLINE IppStatus setLMOTSParams(IppsLMOTSAlgo lmotsOIDAlgo, cpLMOTSParams* params) {
+__IPPCP_INLINE IppStatus setLMOTSParams(IppsLMOTSAlgo lmotsOIDAlgo, cpLMOTSParams* params) {
     switch (lmotsOIDAlgo) {
         case LMOTS_SHA256_N32_W1: {
             params->w = 1;
@@ -134,11 +134,11 @@ __INLINE IppStatus setLMOTSParams(IppsLMOTSAlgo lmotsOIDAlgo, cpLMOTSParams* par
  *    Target element of a specified length
  *
  */
-__INLINE Ipp32u cpCoef(Ipp8u* S, Ipp32u i, Ipp32u w) {
+__IPPCP_INLINE Ipp32u cpCoef(Ipp8u* S, Ipp32u i, Ipp32u w) {
     return ((1 << w) - 1) & ( S[(i * w) / 8] >> (8 - (w * (i % (8 / w)) + w)));
 }
 
-__INLINE Ipp32u cpCksm(Ipp8u* S, cpLMOTSParams lmotsParams) {
+__IPPCP_INLINE Ipp32u cpCksm(Ipp8u* S, cpLMOTSParams lmotsParams) {
     Ipp32u w = lmotsParams.w;
     Ipp32u n = lmotsParams.n;
     Ipp32u ls = lmotsParams.ls;
diff --git a/sources/include/lms_internal/lms.h b/sources/include/lms_internal/lms.h
index ab345ff..94a341d 100644
--- a/sources/include/lms_internal/lms.h
+++ b/sources/include/lms_internal/lms.h
@@ -86,7 +86,7 @@ struct _cpLMSSignatureState {
  * Output parameters:
  *    params    LMS parameters (h, m, hash_method)
  */
-__INLINE IppStatus setLMSParams(IppsLMSAlgo lmsOIDAlgo, cpLMSParams* params) {
+__IPPCP_INLINE IppStatus setLMSParams(IppsLMSAlgo lmsOIDAlgo, cpLMSParams* params) {
     /* Set h */
     switch (lmsOIDAlgo % 5) {
         case 0: { params->h = 5;  break; } // LMS_SHA256_M32_H5  and LMS_SHA256_M24_H5
diff --git a/sources/include/noexec_stack.inc b/sources/include/noexec_stack.inc
new file mode 100644
index 0000000..fdeee61
--- /dev/null
+++ b/sources/include/noexec_stack.inc
@@ -0,0 +1,47 @@
+;=========================================================================
+; Copyright (C) 2024 Intel Corporation
+;
+; Licensed under the Apache License,  Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; 	http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law  or agreed  to  in  writing,  software
+; distributed under  the License  is  distributed  on  an  "AS IS"  BASIS,
+; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+; See the License for the  specific  language  governing  permissions  and
+; limitations under the License.
+;=========================================================================
+
+
+; Non-executable stacks are desirable for security reasons.
+; Recent Linux linkers will mark the stack as non-executable
+; if and only if all the object files participating in the link
+; step declare a properly configured empty "marker" section
+; called `.note.GNU-stack`.
+
+; Consider including this file into all the `*.asm` files.
+
+
+%ifndef __NOEXEC_STACK_INC__
+%define __NOEXEC_STACK_INC__ 1
+
+; noexec stack
+%ifdef LINUX32
+  %ifndef OSX32
+section .note.GNU-stack noalloc noexec nowrite progbits
+  %endif
+%endif
+
+; noexec stack
+%ifdef LINUX32E
+  %ifndef OSXEM64T
+    %ifndef _ARCH_KNC
+section .note.GNU-stack noalloc noexec nowrite progbits
+    %endif
+  %endif
+%endif
+
+%endif ; __NOEXEC_STACK_INC__
+;;;;;;;;;;;;;;;;;;;;;;;;;; End of file "noexec_stack.inc" ;;;;;;;;;;;;;;;;;;;;;;;;;;
diff --git a/sources/include/owndefs.h b/sources/include/owndefs.h
index b14b24d..0b78bdc 100644
--- a/sources/include/owndefs.h
+++ b/sources/include/owndefs.h
@@ -15,7 +15,7 @@
 *************************************************************************/
 
 //
-//  Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+//  Intel® Cryptography Primitives Library
 //
 //  Purpose:
 //     Internal definitions
@@ -34,15 +34,15 @@
   #include "ippcpdefs.h"
 #endif
 
-#if !defined(__INLINE)
+#if !defined(__IPPCP_INLINE)
 #if defined(__INTEL_COMPILER) || defined(__INTEL_LLVM_COMPILER) || defined(_MSC_VER)
-  #define __INLINE static __inline
+  #define __IPPCP_INLINE static __inline
 #elif defined( __GNUC__ )
-  #define __INLINE static __inline__
+  #define __IPPCP_INLINE static __inline__
 #else
-  #define __INLINE static
+  #define __IPPCP_INLINE static
 #endif
-#endif /*__INLINE*/
+#endif /*__IPPCP_INLINE*/
 
 /* TODO: to check ICX compiler */
 #if !defined(__NOINLINE)
@@ -59,7 +59,7 @@
 #if defined(_MSC_VER)
   #define __FORCEINLINE __forceinline
 #elif defined(__INTEL_COMPILER) || defined(__INTEL_LLVM_COMPILER) || defined( __GNUC__ )
-  #define __FORCEINLINE __INLINE __attribute__((always_inline))
+  #define __FORCEINLINE __IPPCP_INLINE __attribute__((always_inline))
 #else
   #define __FORCEINLINE
 #endif
@@ -267,7 +267,7 @@
 #endif
 
 #if ((_IPP_ARCH == _IPP_ARCH_IA32))
-__INLINE Ipp32s IPP_INT_PTR ( const void* ptr )
+__IPPCP_INLINE Ipp32s IPP_INT_PTR ( const void* ptr )
 {
     union {
         void*   Ptr;
@@ -277,7 +277,7 @@ __INLINE Ipp32s IPP_INT_PTR ( const void* ptr )
     return dd.Int;
 }
 
-__INLINE Ipp32u IPP_UINT_PTR( const void* ptr )
+__IPPCP_INLINE Ipp32u IPP_UINT_PTR( const void* ptr )
 {
     union {
         void*   Ptr;
@@ -287,7 +287,7 @@ __INLINE Ipp32u IPP_UINT_PTR( const void* ptr )
     return dd.Int;
 }
 #elif ((_IPP_ARCH == _IPP_ARCH_EM64T) || (_IPP_ARCH == _IPP_ARCH_LRB2))
-__INLINE Ipp64s IPP_INT_PTR( const void* ptr )
+__IPPCP_INLINE Ipp64s IPP_INT_PTR( const void* ptr )
 {
     union {
         void*   Ptr;
@@ -297,7 +297,7 @@ __INLINE Ipp64s IPP_INT_PTR( const void* ptr )
     return dd.Int;
 }
 
-__INLINE Ipp64u IPP_UINT_PTR( const void* ptr )
+__IPPCP_INLINE Ipp64u IPP_UINT_PTR( const void* ptr )
 {
     union {
         void*    Ptr;
@@ -332,7 +332,7 @@ extern "C" {
 
 /* /////////////////////////////////////////////////////////////////////////////
 
-           Intel IPP Cryptography Context Identification
+           Intel® Cryptography Primitives Library Context Identification
 
   /////////////////////////////////////////////////////////////////////////// */
 
diff --git a/sources/include/stateful_sig_common/common.h b/sources/include/stateful_sig_common/common.h
index 51ad5dc..7f4bf15 100644
--- a/sources/include/stateful_sig_common/common.h
+++ b/sources/include/stateful_sig_common/common.h
@@ -25,7 +25,7 @@
  *    out      resulted array of bytes
  */
 
-__INLINE void toByte(Ipp8u *out, Ipp32s outlen, Ipp32u in) {
+__IPPCP_INLINE void toByte(Ipp8u *out, Ipp32s outlen, Ipp32u in) {
     /* Iterate over out in decreasing order, for big-endianness. */
     for (Ipp32s i = outlen - 1; i >= 0; i--) {
         out[i] = (Ipp8u)(in & 0xff);
diff --git a/sources/include/xmss_internal/wots.h b/sources/include/xmss_internal/wots.h
index 0741070..89cc883 100644
--- a/sources/include/xmss_internal/wots.h
+++ b/sources/include/xmss_internal/wots.h
@@ -62,7 +62,7 @@ IPP_OWN_DECL(IppStatus, WOTS_pkFromSig, (const Ipp8u* M, Ipp8u* sig, Ipp8u* pSee
  *    adrs      changed array of bytes
  */
 
-__INLINE void set_adrs_idx(Ipp8u* adrs, Ipp32u idx, int word_id){
+__IPPCP_INLINE void set_adrs_idx(Ipp8u* adrs, Ipp32u idx, int word_id){
     adrs[4 * word_id + 3] = (Ipp8u) idx        & 0xff;
     adrs[4 * word_id + 2] = (Ipp8u)(idx >>  8) & 0xff;
     adrs[4 * word_id + 1] = (Ipp8u)(idx >> 16) & 0xff;
@@ -79,7 +79,7 @@ __INLINE void set_adrs_idx(Ipp8u* adrs, Ipp32u idx, int word_id){
  *    word_id   int32 idx in the adrs array
  */
 
-__INLINE Ipp8u set_adrs_1_byte(int word_id){
+__IPPCP_INLINE Ipp8u set_adrs_1_byte(int word_id){
     return (Ipp8u)(4 * word_id + 3);
 }
 
@@ -90,7 +90,7 @@ __INLINE Ipp8u set_adrs_1_byte(int word_id){
  *    x   double precision floating point value
  */
 
-__INLINE Ipp32s cpCeil(double x) {
+__IPPCP_INLINE Ipp32s cpCeil(double x) {
     Ipp32s int_val = (Ipp32s) x;
     if(int_val == x || x <= 0.0){
         return int_val;
diff --git a/sources/include/xmss_internal/xmss.h b/sources/include/xmss_internal/xmss.h
index 6145cda..b765bd7 100644
--- a/sources/include/xmss_internal/xmss.h
+++ b/sources/include/xmss_internal/xmss.h
@@ -98,7 +98,7 @@ IPP_OWN_DECL(IppStatus, rand_hash, (Ipp8u* left, Ipp8u* right, Ipp8u* seed,
  *    params    WOTS parameters (w, log2_w, n, len, len_1, hash_method)
  */
 
-__INLINE IppStatus setXMSSParams(IppsXMSSAlgo OIDAlgo, Ipp32s* h, cpWOTSParams* params) {
+__IPPCP_INLINE IppStatus setXMSSParams(IppsXMSSAlgo OIDAlgo, Ipp32s* h, cpWOTSParams* params) {
 
     // Digits below are from the XMSS algo spec
     // don't depend on the algo
diff --git a/sources/ippcp/CMakeLists.txt b/sources/ippcp/CMakeLists.txt
index 34acf9b..1864c1a 100644
--- a/sources/ippcp/CMakeLists.txt
+++ b/sources/ippcp/CMakeLists.txt
@@ -15,7 +15,7 @@
 #=========================================================================
 
 #
-# Intel® Integrated Performance Primitives Cryptography (Intel® IPP Cryptography)
+# Intel® Cryptography Primitives Library
 #
 
 include (GenerateExportHeader)
@@ -32,19 +32,24 @@ if (NOT MERGED_BLD)
 endif()
 if(WIN32)
   if(${ARCH} MATCHES "ia32")
-    set(BASE_PLATFORM_LIST ${BASE_PLATFORM_LIST} w7 s8 p8 g9 h9)
+    set(BASE_PLATFORM_LIST_1CPU ${BASE_PLATFORM_LIST} w7 s8 p8 g9 h9)
+    set(BASE_PLATFORM_LIST ${BASE_PLATFORM_LIST} w7 p8 h9)
   else()
-    set(BASE_PLATFORM_LIST ${BASE_PLATFORM_LIST} m7 n8 y8 e9 l9 k0 k1)
+    set(BASE_PLATFORM_LIST_1CPU ${BASE_PLATFORM_LIST} m7 n8 y8 e9 l9 k0 k1)
+    set(BASE_PLATFORM_LIST ${BASE_PLATFORM_LIST} m7 y8 l9 k0 k1)
   endif()
 endif(WIN32)
 if(UNIX)
   if(APPLE)
-    set(BASE_PLATFORM_LIST ${BASE_PLATFORM_LIST} y8 e9 l9 k0 k1)
+    set(BASE_PLATFORM_LIST_1CPU ${BASE_PLATFORM_LIST} y8 e9 l9 k0 k1)
+    set(BASE_PLATFORM_LIST ${BASE_PLATFORM_LIST} y8 l9 k0 k1)
   else()
     if (${ARCH} MATCHES "ia32")
-      set(BASE_PLATFORM_LIST ${BASE_PLATFORM_LIST} w7 s8 p8 g9 h9)
+      set(BASE_PLATFORM_LIST_1CPU ${BASE_PLATFORM_LIST} w7 s8 p8 g9 h9)
+      set(BASE_PLATFORM_LIST ${BASE_PLATFORM_LIST} w7 p8 h9)
     else()
-      set(BASE_PLATFORM_LIST ${BASE_PLATFORM_LIST} m7 n8 y8 e9 l9 k0 k1)
+      set(BASE_PLATFORM_LIST_1CPU ${BASE_PLATFORM_LIST} m7 n8 y8 e9 l9 k0 k1)
+      set(BASE_PLATFORM_LIST ${BASE_PLATFORM_LIST} m7 y8 l9 k0 k1)
     endif(${ARCH} MATCHES "ia32")
   endif(APPLE)
 endif(UNIX)
@@ -53,12 +58,12 @@ if(PLATFORM_LIST)
   if (NOT MERGED_BLD)
     foreach(opt ${PLATFORM_LIST})
       set(FOUND_PLATFORM false)
-      foreach(base_opt ${BASE_PLATFORM_LIST})
+      foreach(base_opt ${BASE_PLATFORM_LIST_1CPU})
         string(STRIP "${opt}" opt_strip)
         if(opt_strip STREQUAL base_opt)
           set(FOUND_PLATFORM true)
         endif()
-      endforeach(base_opt ${BASE_PLATFORM_LIST})
+      endforeach(base_opt ${BASE_PLATFORM_LIST_1CPU})
       if(NOT FOUND_PLATFORM)
         message (FATAL_ERROR "Incorrect platform: " ${opt})
       endif()
@@ -177,7 +182,7 @@ endif()
 message(STATUS "ASM compiler version .................. " ${CMAKE_ASM_NASM_COMPILER})
 message(STATUS "ASM object format ..................... " ${CMAKE_ASM_NASM_OBJECT_FORMAT})
 
-# set Intel IPP Cryptography revision, if required
+# set Intel Cryptography Primitives Library revision, if required
 if(IPP_REVISION)
   # IPP_REVISION - release revision id, added into LibraryVersion
   set(LIBRARY_DEFINES "${LIBRARY_DEFINES} -DIPP_REVISION=${IPP_REVISION}")
@@ -187,7 +192,7 @@ endif()
 set(LIBRARY_DEFINES "${LIBRARY_DEFINES} -DIPPCP_PREVIEW_XMSS -DIPPCP_PREVIEW_LMS")
 
 set(LIBRARY_DEFINES "${LIBRARY_DEFINES} -D_NO_IPP_DEPRECATED") # do not warn about ippcp deprecated functions
-# set BN_OPENSSL_DISABLE for Intel IPP Cryptography
+# set BN_OPENSSL_DISABLE for Intel Cryptography Primitives Library
 # set(LIBRARY_DEFINES "${LIBRARY_DEFINES} -DBN_OPENSSL_DISABLE")
 
 if(IPPCP_FIPS_MODE)
@@ -219,8 +224,6 @@ file(GLOB IPPCP_PUBLIC_HEADERS
 
 file(GLOB LIBRARY_HEADERS
     ${IPP_CRYPTO_SOURCES_DIR}/*.h
-    ${IPP_CRYPTO_SOURCES_DIR}/ecnist/*.h
-    ${IPP_CRYPTO_SOURCES_DIR}/sm2/*.h
     ${IPP_CRYPTO_SOURCES_INCLUDE_DIR}/*.h
     ${IPP_CRYPTO_INCLUDE_DIR}/ippcp*.h
     # RSA_SB (ifma) uses crypto_mb headers
@@ -229,8 +232,10 @@ file(GLOB LIBRARY_HEADERS
 
 file(GLOB LIBRARY_C_SOURCES_ORIGINAL
     ${IPP_CRYPTO_SOURCES_DIR}/*.c
-    ${IPP_CRYPTO_SOURCES_DIR}/ecnist/*.c
-    ${IPP_CRYPTO_SOURCES_DIR}/sm2/*.c
+    ${IPP_CRYPTO_SOURCES_DIR}/hash/*.c
+    ${IPP_CRYPTO_SOURCES_DIR}/hash/*/*.c
+    ${IPP_CRYPTO_SOURCES_DIR}/gfpec/*.c
+    ${IPP_CRYPTO_SOURCES_DIR}/gfpec/*/*.c
     ${IPP_CRYPTO_SOURCES_DIR}/xmss/*.c
     ${IPP_CRYPTO_SOURCES_DIR}/lms/*.c
 )
@@ -239,12 +244,10 @@ file(GLOB LIBRARY_ASM_SOURCES_ORIGINAL
         ${IPP_CRYPTO_SOURCES_DIR}/asm_${ARCH}/*.asm
     )
 
-set(INTERNAL_INCLUDE_DIR ${CMAKE_BINARY_DIR}/include/autogen)
+set(INTERNAL_INCLUDE_DIR ${CMAKE_BINARY_DIR}/include/autogen_1cpu)
 
 set (C_INCLUDE_DIRECTORIES
     ${IPP_CRYPTO_SOURCES_DIR}
-    ${IPP_CRYPTO_SOURCES_DIR}/ecnist
-    ${IPP_CRYPTO_SOURCES_DIR}/sm2
     ${IPP_CRYPTO_SOURCES_INCLUDE_DIR}
     ${IPP_CRYPTO_INCLUDE_DIR}
     ${INTERNAL_INCLUDE_DIR}
@@ -353,6 +356,7 @@ foreach( OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES})
    string( TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG )
    file(COPY ${IPP_CRYPTO_INCLUDE_DIR}/ippcp.h
              ${IPP_CRYPTO_INCLUDE_DIR}/ippcpdefs.h
+             ${IPP_CRYPTO_INCLUDE_DIR}/ippcpversion.h
              ${IPP_CRYPTO_INCLUDE_DIR}/ippversion.h
              ${ONE_CPU_FOLDER}
         DESTINATION "${CMAKE_OUTPUT_DIR}/${OUTPUTCONFIG}/include")
@@ -547,14 +551,24 @@ if(MERGED_BLD)
           PUBLIC_HEADER DESTINATION "include"
           PRIVATE_HEADER DESTINATION "tools/${ARCH}/staticlib")
 
+  set_source_files_properties(${DISPATCHER_ASM_SOURCES} PROPERTIES INCLUDE_DIRECTORIES "${ASM_INCLUDE_DIRECTORIES}")
+
+  # Intel® C++ Compiler specific - the dispatcher also contains C source code
+  # that doesn't use build settings from CMAKE_C/CXX_FLAGS_DEBUG/RELEASE 
   set_source_files_properties(${DISPATCHER_C_SOURCES} pcpver.rc PROPERTIES INCLUDE_DIRECTORIES "${C_INCLUDE_DIRECTORIES}")
   # protection (_FORTIFY_SOURCE) and optimization flags for dispatcher
   if(UNIX)
+    set(DISPATCHER_C_SOURCES_COMPILE_FLAGS "-D_GNU_SOURCE -O2")
+    if(CMAKE_BUILD_TYPE STREQUAL "Release")
+      set(DISPATCHER_C_SOURCES_COMPILE_FLAGS "${DISPATCHER_C_SOURCES_COMPILE_FLAGS} -D_FORTIFY_SOURCE=2")
+    endif()
+
     if(${ARCH} MATCHES "ia32")
-      set_source_files_properties(${DISPATCHER_C_SOURCES} PROPERTIES COMPILE_FLAGS "${CC_FLAGS_INLINE_ASM_UNIX_IA32} -D_GNU_SOURCE -D_FORTIFY_SOURCE=2 -O2")
+      set(DISPATCHER_C_SOURCES_COMPILE_FLAGS " ${CC_FLAGS_INLINE_ASM_UNIX_IA32} ${DISPATCHER_C_SOURCES_COMPILE_FLAGS}")
     else()
-      set_source_files_properties(${DISPATCHER_C_SOURCES} PROPERTIES COMPILE_FLAGS "${CC_FLAGS_INLINE_ASM_UNIX_INTEL64} -D_GNU_SOURCE -D_FORTIFY_SOURCE=2 -O2")
+      set(DISPATCHER_C_SOURCES_COMPILE_FLAGS "${CC_FLAGS_INLINE_ASM_UNIX_INTEL64} ${DISPATCHER_C_SOURCES_COMPILE_FLAGS}")
     endif()
+    set_source_files_properties(${DISPATCHER_C_SOURCES} PROPERTIES COMPILE_FLAGS "${DISPATCHER_C_SOURCES_COMPILE_FLAGS}")
   endif()
 
   # Single merged dynamic lib
diff --git a/sources/ippcp/asm_ia32/pcpbnumulschoolv8as.asm b/sources/ippcp/asm_ia32/pcpbnumulschoolv8as.asm
index c7dd861..2d2523a 100644
--- a/sources/ippcp/asm_ia32/pcpbnumulschoolv8as.asm
+++ b/sources/ippcp/asm_ia32/pcpbnumulschoolv8as.asm
@@ -733,19 +733,19 @@ segment .text align=IPP_ALIGN_FACTOR
 ;; Caller = ippsMontExp
 ;; Caller = ippsModInv_BN
 ;;
-;; Caller = ippsECCPGetPoint
-;; Caller = ippsECCPCheckPoint
-;; Caller = ippsECCPAddPoint
-;; Caller = ippsECCPMulPointScalar
-;; Caller = ippsECCPGenKeyPair
-;; Caller = ippsECCPPublicKey
-;; Caller = ippsECCPValidateKey
-;; Caller = ippsECCPShareSecretKeyDH
-;; Caller = ippsECCPShareSecretKeyDHC
-;; Caller = ippsECCPSignDSA
-;; Caller = ippsECCPSignNR
-;; Caller = ippsECCPVerifyDSA
-;; Caller = ippsECCPVerifyNR
+;; Caller = ippsGFpECGetPointRegular
+;; Caller = ippsGFpECTstPoint
+;; Caller = ippsGFpECAddPoint
+;; Caller = ippsGFpECMulPoint
+;; Caller = ippsGFpECPrivateKey
+;; Caller = ippsGFpECPublicKey
+;; Caller = ippsGFpECTstKeyPair
+;; Caller = ippsGFpECSharedSecretDH
+;; Caller = ippsGFpECSharedSecretDHC
+;; Caller = ippsGFpECSignDSA
+;; Caller = ippsGFpECSignNR
+;; Caller = ippsGFpECVerifyDSA
+;; Caller = ippsGFpECVerifyNR
 ;;
 IPPASM cpMulAdc_BNU_school,PUBLIC
   USES_GPR esi,edi,ebx
diff --git a/sources/ippcp/asm_ia32/pcpbnusqrw7as.asm b/sources/ippcp/asm_ia32/pcpbnusqrw7as.asm
index 1684c3c..341d370 100644
--- a/sources/ippcp/asm_ia32/pcpbnusqrw7as.asm
+++ b/sources/ippcp/asm_ia32/pcpbnusqrw7as.asm
@@ -408,19 +408,19 @@ segment .text align=IPP_ALIGN_FACTOR
 ;; Caller = ippsMontMul
 ;; Caller = ippsMontExp
 ;;
-;; Caller = ippsECCPGetPoint
-;; Caller = ippsECCPCheckPoint
-;; Caller = ippsECCPAddPoint
-;; Caller = ippsECCPMulPointScalar
-;; Caller = ippsECCPGenKeyPair
-;; Caller = ippsECCPPublicKey
-;; Caller = ippsECCPValidateKey
-;; Caller = ippsECCPShareSecretKeyDH
-;; Caller = ippsECCPShareSecretKeyDHC
-;; Caller = ippsECCPSignDSA
-;; Caller = ippsECCPSignNR
-;; Caller = ippsECCPVerifyDSA
-;; Caller = ippsECCPVerifyNR
+;; Caller = ippsGFpECGetPointRegular
+;; Caller = ippsGFpECTstPoint
+;; Caller = ippsGFpECAddPoint
+;; Caller = ippsGFpECMulPoint
+;; Caller = ippsGFpECPrivateKey
+;; Caller = ippsGFpECPublicKey
+;; Caller = ippsGFpECTstKeyPair
+;; Caller = ippsGFpECSharedSecretDH
+;; Caller = ippsGFpECSharedSecretDHC
+;; Caller = ippsGFpECSignDSA
+;; Caller = ippsGFpECSignNR
+;; Caller = ippsGFpECVerifyDSA
+;; Caller = ippsGFpECVerifyNR
 ;;
 IPPASM cpSqrAdc_BNU_school,PUBLIC
   USES_GPR esi,edi,ebx
diff --git a/sources/ippcp/asm_ia32/pcpmd5w7as.asm b/sources/ippcp/asm_ia32/pcpmd5w7as.asm
index 7f018d5..4f95a04 100644
--- a/sources/ippcp/asm_ia32/pcpmd5w7as.asm
+++ b/sources/ippcp/asm_ia32/pcpmd5w7as.asm
@@ -170,13 +170,9 @@ segment .text align=IPP_ALIGN_FACTOR
 ;;
 ;; Lib = W7
 ;;
-;; Caller = ippsSHA1Update
-;; Caller = ippsSHA1Final
-;; Caller = ippsSHA1MessageDigest
-;;
-;; Caller = ippsHMACSHA1Update
-;; Caller = ippsHMACSHA1Final
-;; Caller = ippsHMACSHA1MessageDigest
+;; Caller = ippsHashUpdate_rmf
+;; Caller = ippsHashFinal_rmf
+;; Caller = ippsHashMessage_rmf
 ;;
 
 align IPP_ALIGN_FACTOR
diff --git a/sources/ippcp/asm_ia32/pcpsha1w7as.asm b/sources/ippcp/asm_ia32/pcpsha1w7as.asm
index 01bbdae..e44b958 100644
--- a/sources/ippcp/asm_ia32/pcpsha1w7as.asm
+++ b/sources/ippcp/asm_ia32/pcpsha1w7as.asm
@@ -280,13 +280,9 @@ segment .text align=IPP_ALIGN_FACTOR
 ;;
 ;; Lib = W7,V8
 ;;
-;; Caller = ippsSHA1Update
-;; Caller = ippsSHA1Final
-;; Caller = ippsSHA1MessageDigest
-;;
-;; Caller = ippsHMACSHA1Update
-;; Caller = ippsHMACSHA1Final
-;; Caller = ippsHMACSHA1MessageDigest
+;; Caller = ippsHashUpdate_rmf
+;; Caller = ippsHashFinal_rmf
+;; Caller = ippsHashMessage_rmf
 ;;
 align IPP_ALIGN_FACTOR
 IPPASM UpdateSHA1,PUBLIC
diff --git a/sources/ippcp/asm_ia32/pcpsha256g9as.asm b/sources/ippcp/asm_ia32/pcpsha256g9as.asm
index 4d090ba..35b5ce0 100644
--- a/sources/ippcp/asm_ia32/pcpsha256g9as.asm
+++ b/sources/ippcp/asm_ia32/pcpsha256g9as.asm
@@ -280,6 +280,11 @@ pByteSwp DB    3,2,1,0, 7,6,5,4, 11,10,9,8, 15,14,13,12
 ;; UpdateSHA256(Ipp32u digest[], Ipp8u dataBlock[], int datalen, Ipp32u K_256[])
 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Caller = ippsHashUpdate_rmf
+;; Caller = ippsHashFinal_rmf
+;; Caller = ippsHashMessage_rmf
+;;
 align IPP_ALIGN_FACTOR
 IPPASM UpdateSHA256,PUBLIC
   USES_GPR esi,edi,ebx,ebp
diff --git a/sources/ippcp/asm_ia32/pcpsha256w7as.asm b/sources/ippcp/asm_ia32/pcpsha256w7as.asm
index faba430..9cb235c 100644
--- a/sources/ippcp/asm_ia32/pcpsha256w7as.asm
+++ b/sources/ippcp/asm_ia32/pcpsha256w7as.asm
@@ -153,21 +153,9 @@ segment .text align=IPP_ALIGN_FACTOR
 ;;
 ;; Lib = W7
 ;;
-;; Caller = ippsSHA256Update
-;; Caller = ippsSHA256Final
-;; Caller = ippsSHA256MessageDigest
-;;
-;; Caller = ippsSHA224Update
-;; Caller = ippsSHA224Final
-;; Caller = ippsSHA224MessageDigest
-;;
-;; Caller = ippsHMACSHA256Update
-;; Caller = ippsHMACSHA256Final
-;; Caller = ippsHMACSHA256MessageDigest
-;;
-;; Caller = ippsHMACSHA224Update
-;; Caller = ippsHMACSHA224Final
-;; Caller = ippsHMACSHA224MessageDigest
+;; Caller = ippsHashUpdate_rmf
+;; Caller = ippsHashFinal_rmf
+;; Caller = ippsHashMessage_rmf
 ;;
 
 align IPP_ALIGN_FACTOR
diff --git a/sources/ippcp/asm_ia32/pcpsha512g9as.asm b/sources/ippcp/asm_ia32/pcpsha512g9as.asm
index b7d4594..7997bc7 100644
--- a/sources/ippcp/asm_ia32/pcpsha512g9as.asm
+++ b/sources/ippcp/asm_ia32/pcpsha512g9as.asm
@@ -250,21 +250,12 @@ pByteSwp DB    7,6,5,4,3,2,1,0, 15,14,13,12,11,10,9,8
 ;;
 ;; Lib = W7, V8, P8
 ;;
-;; Caller = ippsSHA512Update
-;; Caller = ippsSHA512Final
-;; Caller = ippsSHA512MessageDigest
 ;;
-;; Caller = ippsSHA384Update
-;; Caller = ippsSHA384Final
-;; Caller = ippsSHA384MessageDigest
 ;;
-;; Caller = ippsHMACSHA512Update
-;; Caller = ippsHMACSHA512Final
-;; Caller = ippsHMACSHA512MessageDigest
+;; Caller = ippsHashUpdate_rmf
+;; Caller = ippsHashFinal_rmf
+;; Caller = ippsHashMessage_rmf
 ;;
-;; Caller = ippsHMACSHA384Update
-;; Caller = ippsHMACSHA384Final
-;; Caller = ippsHMACSHA384MessageDigest
 ;;
 align IPP_ALIGN_FACTOR
 IPPASM UpdateSHA512,PUBLIC
diff --git a/sources/ippcp/asm_ia32/pcpsha512w7as.asm b/sources/ippcp/asm_ia32/pcpsha512w7as.asm
index a243154..2fec92a 100644
--- a/sources/ippcp/asm_ia32/pcpsha512w7as.asm
+++ b/sources/ippcp/asm_ia32/pcpsha512w7as.asm
@@ -272,21 +272,12 @@ pByteSwp DB    7,6,5,4,3,2,1,0, 15,14,13,12,11,10,9,8
 ;;
 ;; Lib = W7, V8, P8
 ;;
-;; Caller = ippsSHA512Update
-;; Caller = ippsSHA512Final
-;; Caller = ippsSHA512MessageDigest
 ;;
-;; Caller = ippsSHA384Update
-;; Caller = ippsSHA384Final
-;; Caller = ippsSHA384MessageDigest
 ;;
-;; Caller = ippsHMACSHA512Update
-;; Caller = ippsHMACSHA512Final
-;; Caller = ippsHMACSHA512MessageDigest
+;; Caller = ippsHashUpdate_rmf
+;; Caller = ippsHashFinal_rmf
+;; Caller = ippsHashMessage_rmf
 ;;
-;; Caller = ippsHMACSHA384Update
-;; Caller = ippsHMACSHA384Final
-;; Caller = ippsHMACSHA384MessageDigest
 ;;
 align IPP_ALIGN_FACTOR
 IPPASM UpdateSHA512,PUBLIC
diff --git a/sources/ippcp/asm_ia32/pcpvariant.inc b/sources/ippcp/asm_ia32/pcpvariant.inc
index 64b5c32..2264901 100644
--- a/sources/ippcp/asm_ia32/pcpvariant.inc
+++ b/sources/ippcp/asm_ia32/pcpvariant.inc
@@ -15,8 +15,7 @@
 ;=========================================================================
 
 ;
-;               Intel(R) Integrated Performance Primitives
-;                   Cryptographic Primitives (ippcp)
+;               Intel(R) Cryptography Primitives Library
 ;
 ;      Purpose:
 ;         Define ippCP variant
diff --git a/sources/ippcp/asm_ia32/pcpvariant_txt_acm.inc b/sources/ippcp/asm_ia32/pcpvariant_txt_acm.inc
index ee9b7d3..a7a8e46 100644
--- a/sources/ippcp/asm_ia32/pcpvariant_txt_acm.inc
+++ b/sources/ippcp/asm_ia32/pcpvariant_txt_acm.inc
@@ -14,8 +14,7 @@
 ; limitations under the License.
 ;=========================================================================
 
-;               Intel(R) Integrated Performance Primitives
-;                   Cryptographic Primitives (ippcp)
+;               Intel(R) Cryptography Primitives Library
 ;
 ;      Purpose:
 ;        Update standard ippCP variant
diff --git a/sources/ippcp/asm_ia32/pcpvariant_xmm7560.inc b/sources/ippcp/asm_ia32/pcpvariant_xmm7560.inc
index 9d2e593..456f19d 100644
--- a/sources/ippcp/asm_ia32/pcpvariant_xmm7560.inc
+++ b/sources/ippcp/asm_ia32/pcpvariant_xmm7560.inc
@@ -14,8 +14,7 @@
 ; limitations under the License.
 ;=========================================================================
 
-;               Intel(R) Integrated Performance Primitives
-;                   Cryptographic Primitives (ippcp)
+;               Intel(R) Cryptography Primitives Library
 ;
 ;     Purpose:
 ;        Update standard ippCP variant
diff --git a/sources/ippcp/asm_intel64/gcm_vaes_avx512.inc b/sources/ippcp/asm_intel64/gcm_vaes_avx512.inc
index 1092bf3..53631d2 100644
--- a/sources/ippcp/asm_intel64/gcm_vaes_avx512.inc
+++ b/sources/ippcp/asm_intel64/gcm_vaes_avx512.inc
@@ -1272,7 +1272,7 @@
 %define %%ZT7                   %21 ; [clobbered] ZMM temporary
 %define %%ZT8                   %22 ; [clobbered] ZMM temporary
 %define %%GH                    %23 ; [in] ZMM with hi product part
-%define %%GM                    %24 ; [in] ZMM with mid prodcut part
+%define %%GM                    %24 ; [in] ZMM with mid product part
 %define %%GL                    %25 ; [in] ZMM with lo product part
 
 
diff --git a/sources/ippcp/asm_intel64/pcpaesgcme9as.asm b/sources/ippcp/asm_intel64/pcpaesgcme9as.asm
index a9dd108..62384c3 100644
--- a/sources/ippcp/asm_intel64/pcpaesgcme9as.asm
+++ b/sources/ippcp/asm_intel64/pcpaesgcme9as.asm
@@ -248,7 +248,7 @@ IPPASM AesGcmPrecompute_avx,PUBLIC
 %xdefine pPrecomData rdi ; (rdi) pointer to the reflected multipliers reflect(hkey),(hkey<<1), (hkey^2)<<1, (hkey^4)<<1,
 %xdefine pHKey       rsi ; (rsi) pointer to the Hkey value
 
-   movdqu   xmm0, oword [rel pHKey] ;  xmm0 holds HashKey
+   movdqu   xmm0, oword [pHKey] ;  xmm0 holds HashKey
    pshufb   xmm0, [rel SHUF_CONST]
   ;movdqu   oword [pPrecomData+sizeof_oword_*0], xmm0
 
@@ -296,7 +296,7 @@ IPPASM AesGcmPrecompute_avx2_vaes,PUBLIC
 %xdefine pPrecomputedData rdi ; (rdi) pointer to the reflected multipliers reflect(hkey),(hkey<<1), (hkey^2)<<1, (hkey^4)<<1,
 %xdefine pHKey       rsi ; (rsi) pointer to the Hkey value
 
-   movdqu   xmm0, oword [rel pHKey] ;  xmm0 holds HashKey
+   movdqu   xmm0, oword [pHKey] ;  xmm0 holds HashKey
    pshufb   xmm0, [rel SHUF_CONST]
 
    ; precompute HashKey<<1 mod poly from the HashKey
@@ -381,14 +381,14 @@ IPPASM AesGcmMulGcm_avx,PUBLIC
 %xdefine pHash   rdi         ; (rdi) pointer to the Hash value
 %xdefine pHKey   rsi         ; (rsi) pointer to the (hkey<<1) value
 
-   movdqa   xmm0, oword [rel pHash]
+   movdqa   xmm0, oword [pHash]
    pshufb   xmm0, [rel SHUF_CONST]
-   movdqa   xmm1, oword [rel pHKey]
+   movdqa   xmm1, oword [pHKey]
 
    sse_clmul_gcm  xmm0, xmm1, xmm2, xmm3, xmm4  ; xmm0 holds Hash*HKey mod poly
 
    pshufb   xmm0, [rel SHUF_CONST]
-   movdqa   oword [rel pHash], xmm0
+   movdqa   oword [pHash], xmm0
 
    REST_XMM
    REST_GPR
@@ -413,15 +413,15 @@ IPPASM AesGcmAuth_avx,PUBLIC
 
 %assign  BYTES_PER_BLK (16)
 
-   movdqa   xmm0, oword [rel pHash]
+   movdqa   xmm0, oword [pHash]
    pshufb   xmm0, [rel SHUF_CONST]
-   movdqa   xmm1, oword [rel pHKey]
+   movdqa   xmm1, oword [pHKey]
 
    movsxd   rdx, edx
 
 align IPP_ALIGN_FACTOR
 .auth_loop:
-   movdqu   xmm2, oword [rel pSrc]  ; src[]
+   movdqu   xmm2, oword [pSrc]  ; src[]
    pshufb   xmm2, [rel SHUF_CONST]
    add      pSrc, BYTES_PER_BLK
    pxor     xmm0, xmm2              ; hash ^= src[]
diff --git a/sources/ippcp/asm_intel64/pcpbnudivm7as.asm b/sources/ippcp/asm_intel64/pcpbnudivm7as.asm
index fc12582..7c53cb5 100644
--- a/sources/ippcp/asm_intel64/pcpbnudivm7as.asm
+++ b/sources/ippcp/asm_intel64/pcpbnudivm7as.asm
@@ -158,7 +158,7 @@
 
 
 ;;
-;; Multuply BNU by 32-bit digit and Subtract
+;; Multiply BNU by 32-bit digit and Subtract
 ;;
 ;; input
 ;;    rSrc     points source BNU
diff --git a/sources/ippcp/asm_intel64/pcpsha1e9as.asm b/sources/ippcp/asm_intel64/pcpsha1e9as.asm
index badb442..36561c2 100644
--- a/sources/ippcp/asm_intel64/pcpsha1e9as.asm
+++ b/sources/ippcp/asm_intel64/pcpsha1e9as.asm
@@ -316,13 +316,11 @@ segment .text align=IPP_ALIGN_FACTOR
 ;;
 ;; Lib = Y8
 ;;
-;; Caller = ippsSHA1Update
-;; Caller = ippsSHA1Final
-;; Caller = ippsSHA1MessageDigest
 ;;
-;; Caller = ippsHMACSHA1Update
-;; Caller = ippsHMACSHA1Final
-;; Caller = ippsHMACSHA1MessageDigest
+;; Caller = ippsHashUpdate_rmf
+;; Caller = ippsHashFinal_rmf
+;; Caller = ippsHashMessage_rmf
+;;
 ;;
 
 ;; assign hash values to GPU registers
diff --git a/sources/ippcp/asm_intel64/pcpsha1m7as.asm b/sources/ippcp/asm_intel64/pcpsha1m7as.asm
index d3e4cea..a82d828 100644
--- a/sources/ippcp/asm_intel64/pcpsha1m7as.asm
+++ b/sources/ippcp/asm_intel64/pcpsha1m7as.asm
@@ -271,13 +271,9 @@ segment .text align=IPP_ALIGN_FACTOR
 ;;
 ;; Lib = M7
 ;;
-;; Caller = ippsSHA1Update
-;; Caller = ippsSHA1Final
-;; Caller = ippsSHA1MessageDigest
-;;
-;; Caller = ippsHMACSHA1Update
-;; Caller = ippsHMACSHA1Final
-;; Caller = ippsHMACSHA1MessageDigest
+;; Caller = ippsHashUpdate_rmf
+;; Caller = ippsHashFinal_rmf
+;; Caller = ippsHashMessage_rmf
 ;;
 
 align IPP_ALIGN_FACTOR
diff --git a/sources/ippcp/asm_intel64/pcpsha1u8as.asm b/sources/ippcp/asm_intel64/pcpsha1u8as.asm
index 08355ca..265393e 100644
--- a/sources/ippcp/asm_intel64/pcpsha1u8as.asm
+++ b/sources/ippcp/asm_intel64/pcpsha1u8as.asm
@@ -330,13 +330,9 @@ segment .text align=IPP_ALIGN_FACTOR
 ;;
 ;; Lib = U8, N8
 ;;
-;; Caller = ippsSHA1Update
-;; Caller = ippsSHA1Final
-;; Caller = ippsSHA1MessageDigest
-;;
-;; Caller = ippsHMACSHA1Update
-;; Caller = ippsHMACSHA1Final
-;; Caller = ippsHMACSHA1MessageDigest
+;; Caller = ippsHashUpdate_rmf
+;; Caller = ippsHashFinal_rmf
+;; Caller = ippsHashMessage_rmf
 ;;
 
 ;; assign hash values to GPU registers
diff --git a/sources/ippcp/asm_intel64/pcpsha256m7as.asm b/sources/ippcp/asm_intel64/pcpsha256m7as.asm
index b60fe3e..612419b 100644
--- a/sources/ippcp/asm_intel64/pcpsha256m7as.asm
+++ b/sources/ippcp/asm_intel64/pcpsha256m7as.asm
@@ -173,21 +173,9 @@
 ;;
 ;; Lib = M7
 ;;
-;; Caller = ippsSHA256Update
-;; Caller = ippsSHA256Final
-;; Caller = ippsSHA256MessageDigest
-;;
-;; Caller = ippsSHA224Update
-;; Caller = ippsSHA224Final
-;; Caller = ippsSHA224MessageDigest
-;;
-;; Caller = ippsHMACSHA256Update
-;; Caller = ippsHMACSHA256Final
-;; Caller = ippsHMACSHA256MessageDigest
-;;
-;; Caller = ippsHMACSHA224Update
-;; Caller = ippsHMACSHA224Final
-;; Caller = ippsHMACSHA224MessageDigest
+;; Caller = ippsHashUpdate_rmf
+;; Caller = ippsHashFinal_rmf
+;; Caller = ippsHashMessage_rmf
 ;;
 
 segment .data align=IPP_ALIGN_FACTOR
diff --git a/sources/ippcp/asm_intel64/pcpsha512m7as.asm b/sources/ippcp/asm_intel64/pcpsha512m7as.asm
index f17bbcb..baaa5c2 100644
--- a/sources/ippcp/asm_intel64/pcpsha512m7as.asm
+++ b/sources/ippcp/asm_intel64/pcpsha512m7as.asm
@@ -188,21 +188,10 @@ segment .text align=IPP_ALIGN_FACTOR
 ;;
 ;; Lib = M7
 ;;
-;; Caller = ippsSHA512Update
-;; Caller = ippsSHA512Final
-;; Caller = ippsSHA512MessageDigest
 ;;
-;; Caller = ippsSHA384Update
-;; Caller = ippsSHA384Final
-;; Caller = ippsSHA384MessageDigest
-;;
-;; Caller = ippsHMACSHA512Update
-;; Caller = ippsHMACSHA512Final
-;; Caller = ippsHMACSHA512MessageDigest
-;;
-;; Caller = ippsHMACSHA384Update
-;; Caller = ippsHMACSHA384Final
-;; Caller = ippsHMACSHA384MessageDigest
+;; Caller = ippsHashUpdate_rmf
+;; Caller = ippsHashFinal_rmf
+;; Caller = ippsHashMessage_rmf
 ;;
 
 %xdefine KK_SHA512  rbp
diff --git a/sources/ippcp/asm_intel64/pcpsm3l9_ni_as.asm b/sources/ippcp/asm_intel64/pcpsm3l9_ni_as.asm
new file mode 100644
index 0000000..1e6b097
--- /dev/null
+++ b/sources/ippcp/asm_intel64/pcpsm3l9_ni_as.asm
@@ -0,0 +1,231 @@
+;=========================================================================