@crossbind/bridge-tools 0.0.0-stage → 2.0.0-beta.72

package/dist/clang/include/avx10v2auxintrin.h

@@ -0,0 +1,2403 @@
+/*===---------------- avx10v2auxintrin.h - AVX10V2AUX ---------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx10v2auxintrin.h> directly; include <immintrin.h> instead."
+#endif // __IMMINTRIN_H
+
+#ifdef __SSE2__
+
+#ifndef __AVX10V2AUXINTRIN_H
+#define __AVX10V2AUXINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__, __target__("avx10v2aux"),     \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__, __target__("avx10v2aux"),     \
+                 __min_vector_width__(256)))
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed BF8 (8-bit) floating-point elements, and store the results in
+///    a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2BF8 instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtps_bf8(__m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2bf8_128_mask(
+      (__v4sf)__A, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed BF8 (8-bit) floating-point elements, and store the results in
+///    a 128-bit vector using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2BF8 instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_mask_cvtps_bf8(__m128i __W,
+                                                                   __mmask8 __U,
+                                                                   __m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2bf8_128_mask((__v4sf)__A, (__v16qi)__W,
+                                                     (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed BF8 (8-bit) floating-point elements, and store the results in
+///    a 128-bit vector using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2BF8 instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtps_bf8(__mmask8 __U, __m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2bf8_128_mask(
+      (__v4sf)__A, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed BF8 (8-bit) floating-point elements, and store the results in
+///    a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2BF8 instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_cvtps_bf8(__m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2bf8_256_mask(
+      (__v8sf)__A, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed BF8 (8-bit) floating-point elements, and store the results in
+///    a 128-bit vector using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2BF8 instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtps_bf8(__m128i __W, __mmask8 __U, __m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2bf8_256_mask((__v8sf)__A, (__v16qi)__W,
+                                                     (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed BF8 (8-bit) floating-point elements, and store the results in
+///    a 128-bit vector using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2BF8 instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtps_bf8(__mmask8 __U, __m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2bf8_256_mask(
+      (__v8sf)__A, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed BF8 (8-bit) floating-point elements with saturation, and store
+///    the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2BF8S instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvts_ps_bf8(__m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2bf8s_128_mask(
+      (__v4sf)__A, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed BF8 (8-bit) floating-point elements with saturation, and store
+///    the results in a 128-bit vector using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2BF8S instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvts_ps_bf8(__m128i __W, __mmask8 __U, __m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2bf8s_128_mask((__v4sf)__A, (__v16qi)__W,
+                                                      (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed BF8 (8-bit) floating-point elements with saturation, and store
+///    the results in a 128-bit vector using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2BF8S instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvts_ps_bf8(__mmask8 __U, __m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2bf8s_128_mask(
+      (__v4sf)__A, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed BF8 (8-bit) floating-point elements with saturation, and store
+///    the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2BF8S instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_cvts_ps_bf8(__m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2bf8s_256_mask(
+      (__v8sf)__A, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed BF8 (8-bit) floating-point elements with saturation, and store
+///    the results in a 128-bit vector using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2BF8S instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvts_ps_bf8(__m128i __W, __mmask8 __U, __m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2bf8s_256_mask((__v8sf)__A, (__v16qi)__W,
+                                                      (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed BF8 (8-bit) floating-point elements with saturation, and store
+///    the results in a 128-bit vector using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2BF8S instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvts_ps_bf8(__mmask8 __U, __m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2bf8s_256_mask(
+      (__v8sf)__A, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements, and store the results in
+///    a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2HF8 instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtps_hf8(__m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2hf8_128_mask(
+      (__v4sf)__A, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements, and store the results in
+///    a 128-bit vector using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2HF8 instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_mask_cvtps_hf8(__m128i __W,
+                                                                   __mmask8 __U,
+                                                                   __m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2hf8_128_mask((__v4sf)__A, (__v16qi)__W,
+                                                     (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements, and store the results in
+///    a 128-bit vector using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2HF8 instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtps_hf8(__mmask8 __U, __m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2hf8_128_mask(
+      (__v4sf)__A, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements, and store the results in
+///    a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2HF8 instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_cvtps_hf8(__m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2hf8_256_mask(
+      (__v8sf)__A, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements, and store the results in
+///    a 128-bit vector using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2HF8 instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtps_hf8(__m128i __W, __mmask8 __U, __m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2hf8_256_mask((__v8sf)__A, (__v16qi)__W,
+                                                     (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements, and store the results in
+///    a 128-bit vector using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2HF8 instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtps_hf8(__mmask8 __U, __m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2hf8_256_mask(
+      (__v8sf)__A, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements with saturation, and store
+///    the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2HF8S instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvts_ps_hf8(__m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2hf8s_128_mask(
+      (__v4sf)__A, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements with saturation, and store
+///    the results in a 128-bit vector using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2HF8S instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvts_ps_hf8(__m128i __W, __mmask8 __U, __m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2hf8s_128_mask((__v4sf)__A, (__v16qi)__W,
+                                                      (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements with saturation, and store
+///    the results in a 128-bit vector using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2HF8S instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvts_ps_hf8(__mmask8 __U, __m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2hf8s_128_mask(
+      (__v4sf)__A, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements with saturation, and store
+///    the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2HF8S instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_cvts_ps_hf8(__m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2hf8s_256_mask(
+      (__v8sf)__A, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements with saturation, and store
+///    the results in a 128-bit vector using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2HF8S instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvts_ps_hf8(__m128i __W, __mmask8 __U, __m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2hf8s_256_mask((__v8sf)__A, (__v16qi)__W,
+                                                      (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements with saturation, and store
+///    the results in a 128-bit vector using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTPS2HF8S instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvts_ps_hf8(__mmask8 __U, __m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtps2hf8s_256_mask(
+      (__v8sf)__A, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements using round-to-odd, and
+///    store the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTROPS2HF8 instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtrops_hf8(__m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtrops2hf8_128_mask(
+      (__v4sf)__A, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements using round-to-odd, and
+///    store the results in a 128-bit vector using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTROPS2HF8 instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtrops_hf8(__m128i __W, __mmask8 __U, __m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtrops2hf8_128_mask(
+      (__v4sf)__A, (__v16qi)__W, (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements using round-to-odd, and
+///    store the results in a 128-bit vector using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTROPS2HF8 instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtrops_hf8(__mmask8 __U, __m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtrops2hf8_128_mask(
+      (__v4sf)__A, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements using round-to-odd, and
+///    store the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTROPS2HF8 instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_cvtrops_hf8(__m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtrops2hf8_256_mask(
+      (__v8sf)__A, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements using round-to-odd, and
+///    store the results in a 128-bit vector using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTROPS2HF8 instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtrops_hf8(__m128i __W, __mmask8 __U, __m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtrops2hf8_256_mask(
+      (__v8sf)__A, (__v16qi)__W, (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements using round-to-odd, and
+///    store the results in a 128-bit vector using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTROPS2HF8 instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtrops_hf8(__mmask8 __U, __m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtrops2hf8_256_mask(
+      (__v8sf)__A, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements using round-to-odd with
+///    saturation, and store the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTROPS2HF8S instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvts_rops_hf8(__m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtrops2hf8s_128_mask(
+      (__v4sf)__A, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements using round-to-odd with
+///    saturation, and store the results using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTROPS2HF8S instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvts_rops_hf8(__m128i __W, __mmask8 __U, __m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtrops2hf8s_128_mask(
+      (__v4sf)__A, (__v16qi)__W, (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements using round-to-odd with
+///    saturation, and store the results using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTROPS2HF8S instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvts_rops_hf8(__mmask8 __U, __m128 __A) {
+  return (__m128i)__builtin_ia32_vcvtrops2hf8s_128_mask(
+      (__v4sf)__A, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements using round-to-odd with
+///    saturation, and store the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTROPS2HF8S instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvts_rops_hf8(__m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtrops2hf8s_256_mask(
+      (__v8sf)__A, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements using round-to-odd with
+///    saturation, and store the results using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTROPS2HF8S instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvts_rops_hf8(__m128i __W, __mmask8 __U, __m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtrops2hf8s_256_mask(
+      (__v8sf)__A, (__v16qi)__W, (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+///    to packed HF8 (8-bit) floating-point elements using round-to-odd with
+///    saturation, and store the results using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTROPS2HF8S instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvts_rops_hf8(__mmask8 __U, __m256 __A) {
+  return (__m128i)__builtin_ia32_vcvtrops2hf8s_256_mask(
+      (__v8sf)__A, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed BF8 (8-bit) floating-point elements using bias values from
+///    \a __A, and store the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2BF8 instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x i32] containing bias values.
+/// \param __B
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtbiasps_bf8(__m128i __A,
+                                                                  __m128 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2bf8_128_mask(
+      (__v4si)__A, (__v4sf)__B, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed BF8 (8-bit) floating-point elements using bias values from
+///    \a __A, and store the results using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2BF8 instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector of [4 x i32] containing bias values.
+/// \param __B
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtbiasps_bf8(__m128i __W, __mmask8 __U, __m128i __A, __m128 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2bf8_128_mask(
+      (__v4si)__A, (__v4sf)__B, (__v16qi)__W, (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed BF8 (8-bit) floating-point elements using bias values from
+///    \a __A, and store the results using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2BF8 instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector of [4 x i32] containing bias values.
+/// \param __B
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtbiasps_bf8(__mmask8 __U, __m128i __A, __m128 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2bf8_128_mask(
+      (__v4si)__A, (__v4sf)__B, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed BF8 (8-bit) floating-point elements using bias values from
+///    \a __A, and store the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2BF8 instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x i32] containing bias values.
+/// \param __B
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtbiasps_bf8(__m256i __A, __m256 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2bf8_256_mask(
+      (__v8si)__A, (__v8sf)__B, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed BF8 (8-bit) floating-point elements using bias values from
+///    \a __A, and store the results using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2BF8 instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 256-bit vector of [8 x i32] containing bias values.
+/// \param __B
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtbiasps_bf8(__m128i __W, __mmask8 __U, __m256i __A, __m256 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2bf8_256_mask(
+      (__v8si)__A, (__v8sf)__B, (__v16qi)__W, (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed BF8 (8-bit) floating-point elements using bias values from
+///    \a __A, and store the results using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2BF8 instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 256-bit vector of [8 x i32] containing bias values.
+/// \param __B
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtbiasps_bf8(__mmask8 __U, __m256i __A, __m256 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2bf8_256_mask(
+      (__v8si)__A, (__v8sf)__B, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed BF8 (8-bit) floating-point elements with saturation using bias
+///    values from \a __A, and store the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2BF8S instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x i32] containing bias values.
+/// \param __B
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvts_biasps_bf8(__m128i __A, __m128 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2bf8s_128_mask(
+      (__v4si)__A, (__v4sf)__B, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed BF8 (8-bit) floating-point elements with saturation using bias
+///    values from \a __A, and store the results using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2BF8S instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector of [4 x i32] containing bias values.
+/// \param __B
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvts_biasps_bf8(__m128i __W, __mmask8 __U, __m128i __A, __m128 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2bf8s_128_mask(
+      (__v4si)__A, (__v4sf)__B, (__v16qi)__W, (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed BF8 (8-bit) floating-point elements with saturation using bias
+///    values from \a __A, and store the results using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2BF8S instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector of [4 x i32] containing bias values.
+/// \param __B
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvts_biasps_bf8(__mmask8 __U, __m128i __A, __m128 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2bf8s_128_mask(
+      (__v4si)__A, (__v4sf)__B, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed BF8 (8-bit) floating-point elements with saturation using bias
+///    values from \a __A, and store the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2BF8S instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x i32] containing bias values.
+/// \param __B
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvts_biasps_bf8(__m256i __A, __m256 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2bf8s_256_mask(
+      (__v8si)__A, (__v8sf)__B, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed BF8 (8-bit) floating-point elements with saturation using bias
+///    values from \a __A, and store the results using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2BF8S instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 256-bit vector of [8 x i32] containing bias values.
+/// \param __B
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvts_biasps_bf8(
+    __m128i __W, __mmask8 __U, __m256i __A, __m256 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2bf8s_256_mask(
+      (__v8si)__A, (__v8sf)__B, (__v16qi)__W, (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed BF8 (8-bit) floating-point elements with saturation using bias
+///    values from \a __A, and store the results using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2BF8S instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 256-bit vector of [8 x i32] containing bias values.
+/// \param __B
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvts_biasps_bf8(__mmask8 __U, __m256i __A, __m256 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2bf8s_256_mask(
+      (__v8si)__A, (__v8sf)__B, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed HF8 (8-bit) floating-point elements using bias values from
+///    \a __A, and store the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2HF8 instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x i32] containing bias values.
+/// \param __B
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtbiasps_hf8(__m128i __A,
+                                                                  __m128 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2hf8_128_mask(
+      (__v4si)__A, (__v4sf)__B, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed HF8 (8-bit) floating-point elements using bias values from
+///    \a __A, and store the results using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2HF8 instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector of [4 x i32] containing bias values.
+/// \param __B
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtbiasps_hf8(__m128i __W, __mmask8 __U, __m128i __A, __m128 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2hf8_128_mask(
+      (__v4si)__A, (__v4sf)__B, (__v16qi)__W, (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed HF8 (8-bit) floating-point elements using bias values from
+///    \a __A, and store the results using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2HF8 instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector of [4 x i32] containing bias values.
+/// \param __B
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtbiasps_hf8(__mmask8 __U, __m128i __A, __m128 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2hf8_128_mask(
+      (__v4si)__A, (__v4sf)__B, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed HF8 (8-bit) floating-point elements using bias values from
+///    \a __A, and store the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2HF8 instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x i32] containing bias values.
+/// \param __B
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtbiasps_hf8(__m256i __A, __m256 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2hf8_256_mask(
+      (__v8si)__A, (__v8sf)__B, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed HF8 (8-bit) floating-point elements using bias values from
+///    \a __A, and store the results using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2HF8 instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 256-bit vector of [8 x i32] containing bias values.
+/// \param __B
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtbiasps_hf8(__m128i __W, __mmask8 __U, __m256i __A, __m256 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2hf8_256_mask(
+      (__v8si)__A, (__v8sf)__B, (__v16qi)__W, (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed HF8 (8-bit) floating-point elements using bias values from
+///    \a __A, and store the results using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2HF8 instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 256-bit vector of [8 x i32] containing bias values.
+/// \param __B
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtbiasps_hf8(__mmask8 __U, __m256i __A, __m256 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2hf8_256_mask(
+      (__v8si)__A, (__v8sf)__B, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed HF8 (8-bit) floating-point elements with saturation using bias
+///    values from \a __A, and store the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2HF8S instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x i32] containing bias values.
+/// \param __B
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvts_biasps_hf8(__m128i __A, __m128 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2hf8s_128_mask(
+      (__v4si)__A, (__v4sf)__B, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed HF8 (8-bit) floating-point elements with saturation using bias
+///    values from \a __A, and store the results using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2HF8S instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector of [4 x i32] containing bias values.
+/// \param __B
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvts_biasps_hf8(__m128i __W, __mmask8 __U, __m128i __A, __m128 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2hf8s_128_mask(
+      (__v4si)__A, (__v4sf)__B, (__v16qi)__W, (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed HF8 (8-bit) floating-point elements with saturation using bias
+///    values from \a __A, and store the results using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2HF8S instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector of [4 x i32] containing bias values.
+/// \param __B
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvts_biasps_hf8(__mmask8 __U, __m128i __A, __m128 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2hf8s_128_mask(
+      (__v4si)__A, (__v4sf)__B, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed HF8 (8-bit) floating-point elements with saturation using bias
+///    values from \a __A, and store the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2HF8S instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x i32] containing bias values.
+/// \param __B
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvts_biasps_hf8(__m256i __A, __m256 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2hf8s_256_mask(
+      (__v8si)__A, (__v8sf)__B, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed HF8 (8-bit) floating-point elements with saturation using bias
+///    values from \a __A, and store the results using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2HF8S instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 256-bit vector of [8 x i32] containing bias values.
+/// \param __B
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or the corresponding bytes of \a __W where the mask bit is clear;
+///    the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvts_biasps_hf8(
+    __m128i __W, __mmask8 __U, __m256i __A, __m256 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2hf8s_256_mask(
+      (__v8si)__A, (__v8sf)__B, (__v16qi)__W, (__mmask8)__U);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __B
+///    to packed HF8 (8-bit) floating-point elements with saturation using bias
+///    values from \a __A, and store the results using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBIASPS2HF8S instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 256-bit vector of [8 x i32] containing bias values.
+/// \param __B
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values, or zero where the mask bit is clear; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvts_biasps_hf8(__mmask8 __U, __m256i __A, __m256 __B) {
+  return (__m128i)__builtin_ia32_vcvtbiasps2hf8s_256_mask(
+      (__v8si)__A, (__v8sf)__B, (__v16qi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+/// Convert packed BF8 (8-bit) floating-point elements in \a __A to packed
+///    single-precision (32-bit) floating-point elements, and store the results
+///    in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF82PS instruction.
+///
+/// \param __A
+///    A 128-bit vector of [16 x i8] containing BF8 values.
+/// \returns
+///    A 128-bit vector of [4 x float] containing the converted values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_cvtbf8_ps(__m128i __A) {
+  return (__m128)__builtin_ia32_vcvtbf82ps_128((__v16qi)__A);
+}
+
+/// Convert packed BF8 (8-bit) floating-point elements in \a __A to packed
+///    single-precision (32-bit) floating-point elements, and store the results
+///    using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF82PS instruction.
+///
+/// \param __W
+///    A 128-bit vector of [4 x float] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector of [16 x i8] containing BF8 values.
+/// \returns
+///    A 128-bit vector of [4 x float] containing the converted values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_mask_cvtbf8_ps(__m128 __W,
+                                                                  __mmask8 __U,
+                                                                  __m128i __A) {
+  return (__m128)__builtin_ia32_selectps_128(
+      (__mmask8)__U, (__v4sf)_mm_cvtbf8_ps(__A), (__v4sf)__W);
+}
+
+/// Convert packed BF8 (8-bit) floating-point elements in \a __A to packed
+///    single-precision (32-bit) floating-point elements, and store the results
+///    using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF82PS instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector of [16 x i8] containing BF8 values.
+/// \returns
+///    A 128-bit vector of [4 x float] containing the converted values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtbf8_ps(__mmask8 __U, __m128i __A) {
+  return (__m128)__builtin_ia32_selectps_128(
+      (__mmask8)__U, (__v4sf)_mm_cvtbf8_ps(__A), (__v4sf)_mm_setzero_ps());
+}
+
+/// Convert packed BF8 (8-bit) floating-point elements in \a __A to packed
+///    single-precision (32-bit) floating-point elements, and store the results
+///    in a 256-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF82PS instruction.
+///
+/// \param __A
+///    A 128-bit vector of [16 x i8] containing BF8 values.
+/// \returns
+///    A 256-bit vector of [8 x float] containing the converted values.
+static __inline__ __m256 __DEFAULT_FN_ATTRS256 _mm256_cvtbf8_ps(__m128i __A) {
+  return (__m256)__builtin_ia32_vcvtbf82ps_256((__v16qi)__A);
+}
+
+/// Convert packed BF8 (8-bit) floating-point elements in \a __A to packed
+///    single-precision (32-bit) floating-point elements, and store the results
+///    using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF82PS instruction.
+///
+/// \param __W
+///    A 256-bit vector of [8 x float] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector of [16 x i8] containing BF8 values.
+/// \returns
+///    A 256-bit vector of [8 x float] containing the converted values.
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtbf8_ps(__m256 __W, __mmask8 __U, __m128i __A) {
+  return (__m256)__builtin_ia32_selectps_256(
+      (__mmask8)__U, (__v8sf)_mm256_cvtbf8_ps(__A), (__v8sf)__W);
+}
+
+/// Convert packed BF8 (8-bit) floating-point elements in \a __A to packed
+///    single-precision (32-bit) floating-point elements, and store the results
+///    using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF82PS instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector of [16 x i8] containing BF8 values.
+/// \returns
+///    A 256-bit vector of [8 x float] containing the converted values.
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtbf8_ps(__mmask8 __U, __m128i __A) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_cvtbf8_ps(__A),
+                                             (__v8sf)_mm256_setzero_ps());
+}
+
+/// Convert packed HF8 (8-bit) floating-point elements in \a __A to packed
+///    single-precision (32-bit) floating-point elements, and store the results
+///    in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PS instruction.
+///
+/// \param __A
+///    A 128-bit vector of [16 x i8] containing HF8 values.
+/// \returns
+///    A 128-bit vector of [4 x float] containing the converted values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_cvthf8_ps(__m128i __A) {
+  return (__m128)__builtin_ia32_vcvthf82ps_128((__v16qi)__A);
+}
+
+/// Convert packed HF8 (8-bit) floating-point elements in \a __A to packed
+///    single-precision (32-bit) floating-point elements, and store the results
+///    using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PS instruction.
+///
+/// \param __W
+///    A 128-bit vector of [4 x float] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector of [16 x i8] containing HF8 values.
+/// \returns
+///    A 128-bit vector of [4 x float] containing the converted values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_mask_cvthf8_ps(__m128 __W,
+                                                                  __mmask8 __U,
+                                                                  __m128i __A) {
+  return (__m128)__builtin_ia32_selectps_128(
+      (__mmask8)__U, (__v4sf)_mm_cvthf8_ps(__A), (__v4sf)__W);
+}
+
+/// Convert packed HF8 (8-bit) floating-point elements in \a __A to packed
+///    single-precision (32-bit) floating-point elements, and store the results
+///    using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PS instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector of [16 x i8] containing HF8 values.
+/// \returns
+///    A 128-bit vector of [4 x float] containing the converted values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_cvthf8_ps(__mmask8 __U, __m128i __A) {
+  return (__m128)__builtin_ia32_selectps_128(
+      (__mmask8)__U, (__v4sf)_mm_cvthf8_ps(__A), (__v4sf)_mm_setzero_ps());
+}
+
+/// Convert packed HF8 (8-bit) floating-point elements in \a __A to packed
+///    single-precision (32-bit) floating-point elements, and store the results
+///    in a 256-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PS instruction.
+///
+/// \param __A
+///    A 128-bit vector of [16 x i8] containing HF8 values.
+/// \returns
+///    A 256-bit vector of [8 x float] containing the converted values.
+static __inline__ __m256 __DEFAULT_FN_ATTRS256 _mm256_cvthf8_ps(__m128i __A) {
+  return (__m256)__builtin_ia32_vcvthf82ps_256((__v16qi)__A);
+}
+
+/// Convert packed HF8 (8-bit) floating-point elements in \a __A to packed
+///    single-precision (32-bit) floating-point elements, and store the results
+///    using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PS instruction.
+///
+/// \param __W
+///    A 256-bit vector of [8 x float] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector of [16 x i8] containing HF8 values.
+/// \returns
+///    A 256-bit vector of [8 x float] containing the converted values.
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_cvthf8_ps(__m256 __W, __mmask8 __U, __m128i __A) {
+  return (__m256)__builtin_ia32_selectps_256(
+      (__mmask8)__U, (__v8sf)_mm256_cvthf8_ps(__A), (__v8sf)__W);
+}
+
+/// Convert packed HF8 (8-bit) floating-point elements in \a __A to packed
+///    single-precision (32-bit) floating-point elements, and store the results
+///    using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PS instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector of [16 x i8] containing HF8 values.
+/// \returns
+///    A 256-bit vector of [8 x float] containing the converted values.
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvthf8_ps(__mmask8 __U, __m128i __A) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_cvthf8_ps(__A),
+                                             (__v8sf)_mm256_setzero_ps());
+}
+
+/// Convert packed BF8 (8-bit) floating-point elements in \a __A to packed
+///    BF6 (6-bit) floating-point elements with saturation, and store the
+///    results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF82BF6S instruction.
+///
+/// \param __A
+///    A 128-bit vector of [16 x i8] containing BF8 values.
+/// \returns
+///    A 128-bit vector containing 16 converted packed BF6 values in the
+///    lower bits.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvts_bf8_bf6(__m128i __A) {
+  return (__m128i)__builtin_ia32_vcvtbf82bf6s_128((__v16qi)__A);
+}
+
+/// Convert packed BF8 (8-bit) floating-point elements in \a __A to packed
+///    BF6 (6-bit) floating-point elements with saturation, and store the
+///    results in a 256-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF82BF6S instruction.
+///
+/// \param __A
+///    A 256-bit vector of [32 x i8] containing BF8 values.
+/// \returns
+///    A 256-bit vector containing 32 converted packed BF6 values in the
+///    lower bits.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvts_bf8_bf6(__m256i __A) {
+  return (__m256i)__builtin_ia32_vcvtbf82bf6s_256((__v32qi)__A);
+}
+
+/// Convert packed HF8 (8-bit) floating-point elements in \a __A to packed
+///    HF6 (6-bit) floating-point elements with saturation, and store the
+///    results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82HF6S instruction.
+///
+/// \param __A
+///    A 128-bit vector of [16 x i8] containing HF8 values.
+/// \returns
+///    A 128-bit vector containing 16 converted packed HF6 values in the
+///    lower bits.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvts_hf8_hf6(__m128i __A) {
+  return (__m128i)__builtin_ia32_vcvthf82hf6s_128((__v16qi)__A);
+}
+
+/// Convert packed HF8 (8-bit) floating-point elements in \a __A to packed
+///    HF6 (6-bit) floating-point elements with saturation, and store the
+///    results in a 256-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82HF6S instruction.
+///
+/// \param __A
+///    A 256-bit vector of [32 x i8] containing HF8 values.
+/// \returns
+///    A 256-bit vector containing 32 converted packed HF6 values in the
+///    lower bits.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvts_hf8_hf6(__m256i __A) {
+  return (__m256i)__builtin_ia32_vcvthf82hf6s_256((__v32qi)__A);
+}
+
+/// Convert packed BF8 (8-bit) floating-point elements in \a __A to packed
+///    BF4 (4-bit) floating-point elements with saturation, and store the
+///    results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF82BF4S instruction.
+///
+/// \param __A
+///    A 128-bit vector of [16 x i8] containing BF8 values.
+/// \returns
+///    A 128-bit vector containing 16 converted packed BF4 values in the
+///    lower bits.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvts_bf8_bf4(__m128i __A) {
+  return (__m128i)__builtin_ia32_vcvtbf82bf4s_128((__v16qi)__A);
+}
+
+/// Convert packed BF8 (8-bit) floating-point elements in \a __A to packed
+///    BF4 (4-bit) floating-point elements with saturation, and store the
+///    results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF82BF4S instruction.
+///
+/// \param __A
+///    A 256-bit vector of [32 x i8] containing BF8 values.
+/// \returns
+///    A 128-bit vector containing 32 converted packed BF4 values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvts_bf8_bf4(__m256i __A) {
+  return (__m128i)__builtin_ia32_vcvtbf82bf4s_256((__v32qi)__A);
+}
+
+/// Convert packed HF8 (8-bit) floating-point elements in \a __A to packed
+///    BF4 (4-bit) floating-point elements with saturation, and store the
+///    results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82BF4S instruction.
+///
+/// \param __A
+///    A 128-bit vector of [16 x i8] containing HF8 values.
+/// \returns
+///    A 128-bit vector containing 16 converted packed BF4 values in the
+///    lower bits.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvts_hf8_bf4(__m128i __A) {
+  return (__m128i)__builtin_ia32_vcvthf82bf4s_128((__v16qi)__A);
+}
+
+/// Convert packed HF8 (8-bit) floating-point elements in \a __A to packed
+///    BF4 (4-bit) floating-point elements with saturation, and store the
+///    results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82BF4S instruction.
+///
+/// \param __A
+///    A 256-bit vector of [32 x i8] containing HF8 values.
+/// \returns
+///    A 128-bit vector containing 32 converted packed BF4 values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvts_hf8_bf4(__m256i __A) {
+  return (__m128i)__builtin_ia32_vcvthf82bf4s_256((__v32qi)__A);
+}
+
+/// Convert packed BF4 (4-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results in a 128-bit
+///    vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF42HF8 instruction.
+///
+/// \param __A
+///    A 128-bit vector containing 16 packed BF4 values in the lower bits.
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted HF8 values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtbf4_hf8(__m128i __A) {
+  return (__m128i)__builtin_ia32_vcvtbf42hf8_128((__v16qi)__A);
+}
+
+/// Convert packed BF4 (4-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results using
+///    writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF42HF8 instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 16-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector containing 16 packed BF4 values in the lower bits.
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted HF8 values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtbf4_hf8(__m128i __W, __mmask16 __U, __m128i __A) {
+  return (__m128i)__builtin_ia32_selectb_128(__U, (__v16qi)_mm_cvtbf4_hf8(__A),
+                                             (__v16qi)__W);
+}
+
+/// Convert packed BF4 (4-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results using
+///    zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF42HF8 instruction.
+///
+/// \param __U
+///    A 16-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector containing 16 packed BF4 values in the lower bits.
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted HF8 values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtbf4_hf8(__mmask16 __U, __m128i __A) {
+  return (__m128i)__builtin_ia32_selectb_128(__U, (__v16qi)_mm_cvtbf4_hf8(__A),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+/// Convert packed BF4 (4-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results in a 256-bit
+///    vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF42HF8 instruction.
+///
+/// \param __A
+///    A 128-bit vector containing 32 packed BF4 values.
+/// \returns
+///    A 256-bit vector of [32 x i8] containing the converted HF8 values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_cvtbf4_hf8(__m128i __A) {
+  return (__m256i)__builtin_ia32_vcvtbf42hf8_256((__v16qi)__A);
+}
+
+/// Convert packed BF4 (4-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results using
+///    writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF42HF8 instruction.
+///
+/// \param __W
+///    A 256-bit vector of [32 x i8] used for writemask.
+/// \param __U
+///    A 32-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector containing 32 packed BF4 values.
+/// \returns
+///    A 256-bit vector of [32 x i8] containing the converted HF8 values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtbf4_hf8(__m256i __W, __mmask32 __U, __m128i __A) {
+  return (__m256i)__builtin_ia32_selectb_256(
+      __U, (__v32qi)_mm256_cvtbf4_hf8(__A), (__v32qi)__W);
+}
+
+/// Convert packed BF4 (4-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results using
+///    zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF42HF8 instruction.
+///
+/// \param __U
+///    A 32-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector containing 32 packed BF4 values.
+/// \returns
+///    A 256-bit vector of [32 x i8] containing the converted HF8 values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtbf4_hf8(__mmask32 __U, __m128i __A) {
+  return (__m256i)__builtin_ia32_selectb_256(
+      __U, (__v32qi)_mm256_cvtbf4_hf8(__A), (__v32qi)_mm256_setzero_si256());
+}
+
+/// Convert packed BF6 (6-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results in a 128-bit
+///    vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF62HF8 instruction.
+///
+/// \param __A
+///    A 128-bit vector containing 16 packed BF6 values in the lower bits.
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted HF8 values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtbf6_hf8(__m128i __A) {
+  return (__m128i)__builtin_ia32_vcvtbf62hf8_128((__v16qi)__A);
+}
+
+/// Convert packed BF6 (6-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results using
+///    writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF62HF8 instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 16-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector containing 16 packed BF6 values in the lower bits.
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted HF8 values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtbf6_hf8(__m128i __W, __mmask16 __U, __m128i __A) {
+  return (__m128i)__builtin_ia32_selectb_128(__U, (__v16qi)_mm_cvtbf6_hf8(__A),
+                                             (__v16qi)__W);
+}
+
+/// Convert packed BF6 (6-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results using
+///    zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF62HF8 instruction.
+///
+/// \param __U
+///    A 16-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector containing 16 packed BF6 values in the lower bits.
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted HF8 values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtbf6_hf8(__mmask16 __U, __m128i __A) {
+  return (__m128i)__builtin_ia32_selectb_128(__U, (__v16qi)_mm_cvtbf6_hf8(__A),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+/// Convert packed BF6 (6-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results in a 256-bit
+///    vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF62HF8 instruction.
+///
+/// \param __A
+///    A 256-bit vector containing 32 packed BF6 values in the lower bits.
+/// \returns
+///    A 256-bit vector of [32 x i8] containing the converted HF8 values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_cvtbf6_hf8(__m256i __A) {
+  return (__m256i)__builtin_ia32_vcvtbf62hf8_256((__v32qi)__A);
+}
+
+/// Convert packed BF6 (6-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results using
+///    writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF62HF8 instruction.
+///
+/// \param __W
+///    A 256-bit vector of [32 x i8] used for writemask.
+/// \param __U
+///    A 32-bit mask indicating which elements to write.
+/// \param __A
+///    A 256-bit vector containing 32 packed BF6 values in the lower bits.
+/// \returns
+///    A 256-bit vector of [32 x i8] containing the converted HF8 values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtbf6_hf8(__m256i __W, __mmask32 __U, __m256i __A) {
+  return (__m256i)__builtin_ia32_selectb_256(
+      __U, (__v32qi)_mm256_cvtbf6_hf8(__A), (__v32qi)__W);
+}
+
+/// Convert packed BF6 (6-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results using
+///    zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTBF62HF8 instruction.
+///
+/// \param __U
+///    A 32-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 256-bit vector containing 32 packed BF6 values in the lower bits.
+/// \returns
+///    A 256-bit vector of [32 x i8] containing the converted HF8 values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtbf6_hf8(__mmask32 __U, __m256i __A) {
+  return (__m256i)__builtin_ia32_selectb_256(
+      __U, (__v32qi)_mm256_cvtbf6_hf8(__A), (__v32qi)_mm256_setzero_si256());
+}
+
+/// Convert packed HF6 (6-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results in a 128-bit
+///    vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF62HF8 instruction.
+///
+/// \param __A
+///    A 128-bit vector containing 16 packed HF6 values in the lower bits.
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted HF8 values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvthf6_hf8(__m128i __A) {
+  return (__m128i)__builtin_ia32_vcvthf62hf8_128((__v16qi)__A);
+}
+
+/// Convert packed HF6 (6-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results using
+///    writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF62HF8 instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 16-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector containing 16 packed HF6 values in the lower bits.
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted HF8 values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvthf6_hf8(__m128i __W, __mmask16 __U, __m128i __A) {
+  return (__m128i)__builtin_ia32_selectb_128(__U, (__v16qi)_mm_cvthf6_hf8(__A),
+                                             (__v16qi)__W);
+}
+
+/// Convert packed HF6 (6-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results using
+///    zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF62HF8 instruction.
+///
+/// \param __U
+///    A 16-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector containing 16 packed HF6 values in the lower bits.
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted HF8 values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvthf6_hf8(__mmask16 __U, __m128i __A) {
+  return (__m128i)__builtin_ia32_selectb_128(__U, (__v16qi)_mm_cvthf6_hf8(__A),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+/// Convert packed HF6 (6-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results in a 256-bit
+///    vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF62HF8 instruction.
+///
+/// \param __A
+///    A 256-bit vector containing 32 packed HF6 values in the lower bits.
+/// \returns
+///    A 256-bit vector of [32 x i8] containing the converted HF8 values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_cvthf6_hf8(__m256i __A) {
+  return (__m256i)__builtin_ia32_vcvthf62hf8_256((__v32qi)__A);
+}
+
+/// Convert packed HF6 (6-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results using
+///    writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF62HF8 instruction.
+///
+/// \param __W
+///    A 256-bit vector of [32 x i8] used for writemask.
+/// \param __U
+///    A 32-bit mask indicating which elements to write.
+/// \param __A
+///    A 256-bit vector containing 32 packed HF6 values in the lower bits.
+/// \returns
+///    A 256-bit vector of [32 x i8] containing the converted HF8 values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvthf6_hf8(__m256i __W, __mmask32 __U, __m256i __A) {
+  return (__m256i)__builtin_ia32_selectb_256(
+      __U, (__v32qi)_mm256_cvthf6_hf8(__A), (__v32qi)__W);
+}
+
+/// Convert packed HF6 (6-bit) floating-point elements in \a __A to packed
+///    HF8 (8-bit) floating-point elements, and store the results using
+///    zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF62HF8 instruction.
+///
+/// \param __U
+///    A 32-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 256-bit vector containing 32 packed HF6 values in the lower bits.
+/// \returns
+///    A 256-bit vector of [32 x i8] containing the converted HF8 values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvthf6_hf8(__mmask32 __U, __m256i __A) {
+  return (__m256i)__builtin_ia32_selectb_256(
+      __U, (__v32qi)_mm256_cvthf6_hf8(__A), (__v32qi)_mm256_setzero_si256());
+}
+
+/// Compose the \c size field of the immediate operand of \c VUNPACKB, which
+///    selects the size in bits of the packed source elements.
+///
+/// \headerfile <immintrin.h>
+///
+/// \param n
+///    The packed element size in bits, in the range [2, 7].
+/// \returns
+///    Bits [4:2] of the immediate operand.
+#define _MM_UNPACKB_SIZE(n) (((n) & 0x7) << 2)
+
+/// Compose the \c start field of the immediate operand of \c VUNPACKB, which
+///    selects which block of packed elements is extracted from the source.
+///
+/// \headerfile <immintrin.h>
+///
+/// \param s
+///    The starting offset, in the range [0, 3]. The permitted values depend on
+///    the element size; only offsets that allow a full extraction are valid.
+/// \returns
+///    Bits [1:0] of the immediate operand.
+#define _MM_UNPACKB_START(s) (((s) & 0x3) << 0)
+
+/// The \c sign-extend field of the immediate operand of \c VUNPACKB,
+///    requesting that unpacked elements be sign-extended to 8 bits instead of
+///    zero-extended.
+///
+/// \headerfile <immintrin.h>
+#define _MM_UNPACKB_SEXT (1 << 5)
+
+/// Unpack bytes from \a A according to the immediate value \a imm, and store
+///    the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VUNPACKB instruction.
+///
+/// \param A
+///    A 128-bit vector of [16 x i8].
+/// \param imm
+///    An 8-bit immediate selecting the packed element size, start offset, and
+///    optional sign-extend for \c VUNPACKB. Compose it with
+///    \c _MM_UNPACKB_SIZE, \c _MM_UNPACKB_START, and optionally
+///    \c _MM_UNPACKB_SEXT. Omitting \c _MM_UNPACKB_SEXT zero-extends unpacked
+///    elements to 8 bits. \n
+///    Example:
+///    <c>_MM_UNPACKB_SIZE(4) | _MM_UNPACKB_START(1) | _MM_UNPACKB_SEXT</c>
+///
+/// \see { _MM_UNPACKB_SIZE _MM_UNPACKB_START _MM_UNPACKB_SEXT }
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the unpacked values.
+#define _mm_unpack_epi8(A, imm)                                                \
+  ((__m128i)__builtin_ia32_vunpackb128((__v16qi)(__m128i)(A), (int)(imm)))
+
+/// Unpack bytes from \a A according to the immediate value \a imm, and store
+///    the results in a 128-bit vector using writemask \a U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VUNPACKB instruction.
+///
+/// \param W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param U
+///    A 16-bit mask indicating which elements to write.
+/// \param A
+///    A 128-bit vector of [16 x i8].
+/// \param imm
+///    An 8-bit immediate selecting the packed element size, start offset, and
+///    optional sign-extend for \c VUNPACKB. Compose it with
+///    \c _MM_UNPACKB_SIZE, \c _MM_UNPACKB_START, and optionally
+///    \c _MM_UNPACKB_SEXT. Omitting \c _MM_UNPACKB_SEXT zero-extends unpacked
+///    elements to 8 bits. \n
+///    Example:
+///    <c>_MM_UNPACKB_SIZE(4) | _MM_UNPACKB_START(1) | _MM_UNPACKB_SEXT</c>
+///
+/// \see { _MM_UNPACKB_SIZE _MM_UNPACKB_START _MM_UNPACKB_SEXT }
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the unpacked values.
+#define _mm_mask_unpack_epi8(W, U, A, imm)                                     \
+  ((__m128i)__builtin_ia32_selectb_128((__mmask16)(U),                         \
+                                       (__v16qi)_mm_unpack_epi8((A), (imm)),   \
+                                       (__v16qi)(__m128i)(W)))
+
+/// Unpack bytes from \a A according to the immediate value \a imm, and store
+///    the results in a 128-bit vector using zeromask \a U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VUNPACKB instruction.
+///
+/// \param U
+///    A 16-bit mask indicating which elements to write (zero otherwise).
+/// \param A
+///    A 128-bit vector of [16 x i8].
+/// \param imm
+///    An 8-bit immediate selecting the packed element size, start offset, and
+///    optional sign-extend for \c VUNPACKB. Compose it with
+///    \c _MM_UNPACKB_SIZE, \c _MM_UNPACKB_START, and optionally
+///    \c _MM_UNPACKB_SEXT. Omitting \c _MM_UNPACKB_SEXT zero-extends unpacked
+///    elements to 8 bits. \n
+///    Example:
+///    <c>_MM_UNPACKB_SIZE(4) | _MM_UNPACKB_START(1) | _MM_UNPACKB_SEXT</c>
+///
+/// \see { _MM_UNPACKB_SIZE _MM_UNPACKB_START _MM_UNPACKB_SEXT }
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the unpacked values.
+#define _mm_maskz_unpack_epi8(U, A, imm)                                       \
+  ((__m128i)__builtin_ia32_selectb_128((__mmask16)(U),                         \
+                                       (__v16qi)_mm_unpack_epi8((A), (imm)),   \
+                                       (__v16qi)_mm_setzero_si128()))
+
+/// Unpack bytes from \a A according to the immediate value \a imm, and store
+///    the results in a 256-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VUNPACKB instruction.
+///
+/// \param A
+///    A 256-bit vector of [32 x i8].
+/// \param imm
+///    An 8-bit immediate selecting the packed element size, start offset, and
+///    optional sign-extend for \c VUNPACKB. Compose it with
+///    \c _MM_UNPACKB_SIZE, \c _MM_UNPACKB_START, and optionally
+///    \c _MM_UNPACKB_SEXT. Omitting \c _MM_UNPACKB_SEXT zero-extends unpacked
+///    elements to 8 bits. \n
+///    Example:
+///    <c>_MM_UNPACKB_SIZE(4) | _MM_UNPACKB_START(1) | _MM_UNPACKB_SEXT</c>
+///
+/// \see { _MM_UNPACKB_SIZE _MM_UNPACKB_START _MM_UNPACKB_SEXT }
+/// \returns
+///    A 256-bit vector of [32 x i8] containing the unpacked values.
+#define _mm256_unpack_epi8(A, imm)                                             \
+  ((__m256i)__builtin_ia32_vunpackb256((__v32qi)(__m256i)(A), (int)(imm)))
+
+/// Unpack bytes from \a A according to the immediate value \a imm, and store
+///    the results in a 256-bit vector using writemask \a U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VUNPACKB instruction.
+///
+/// \param W
+///    A 256-bit vector of [32 x i8] used for writemask.
+/// \param U
+///    A 32-bit mask indicating which elements to write.
+/// \param A
+///    A 256-bit vector of [32 x i8].
+/// \param imm
+///    An 8-bit immediate selecting the packed element size, start offset, and
+///    optional sign-extend for \c VUNPACKB. Compose it with
+///    \c _MM_UNPACKB_SIZE, \c _MM_UNPACKB_START, and optionally
+///    \c _MM_UNPACKB_SEXT. Omitting \c _MM_UNPACKB_SEXT zero-extends unpacked
+///    elements to 8 bits. \n
+///    Example:
+///    <c>_MM_UNPACKB_SIZE(4) | _MM_UNPACKB_START(1) | _MM_UNPACKB_SEXT</c>
+///
+/// \see { _MM_UNPACKB_SIZE _MM_UNPACKB_START _MM_UNPACKB_SEXT }
+/// \returns
+///    A 256-bit vector of [32 x i8] containing the unpacked values.
+#define _mm256_mask_unpack_epi8(W, U, A, imm)                                  \
+  ((__m256i)__builtin_ia32_selectb_256(                                        \
+      (__mmask32)(U), (__v32qi)_mm256_unpack_epi8((A), (imm)),                 \
+      (__v32qi)(__m256i)(W)))
+
+/// Unpack bytes from \a A according to the immediate value \a imm, and store
+///    the results in a 256-bit vector using zeromask \a U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VUNPACKB instruction.
+///
+/// \param U
+///    A 32-bit mask indicating which elements to write (zero otherwise).
+/// \param A
+///    A 256-bit vector of [32 x i8].
+/// \param imm
+///    An 8-bit immediate selecting the packed element size, start offset, and
+///    optional sign-extend for \c VUNPACKB. Compose it with
+///    \c _MM_UNPACKB_SIZE, \c _MM_UNPACKB_START, and optionally
+///    \c _MM_UNPACKB_SEXT. Omitting \c _MM_UNPACKB_SEXT zero-extends unpacked
+///    elements to 8 bits. \n
+///    Example:
+///    <c>_MM_UNPACKB_SIZE(4) | _MM_UNPACKB_START(1) | _MM_UNPACKB_SEXT</c>
+///
+/// \see { _MM_UNPACKB_SIZE _MM_UNPACKB_START _MM_UNPACKB_SEXT }
+/// \returns
+///    A 256-bit vector of [32 x i8] containing the unpacked values.
+#define _mm256_maskz_unpack_epi8(U, A, imm)                                    \
+  ((__m256i)__builtin_ia32_selectb_256(                                        \
+      (__mmask32)(U), (__v32qi)_mm256_unpack_epi8((A), (imm)),                 \
+      (__v32qi)_mm256_setzero_si256()))
+
+/// Convert packed signed 32-bit integers in \a __A to packed 8-bit integers
+///    with symmetric signed saturation (clamp to [-127, +127]), and store
+///    the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVSSDB instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x i32].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 4 bytes contain the converted
+///    values; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtss_epi32_epi8(__m128i __A) {
+  return (__m128i)__builtin_ia32_vpmovssdb128_mask(
+      (__v4si)__A, (__v16qi)_mm_setzero_si128(), (__mmask8)-1);
+}
+
+/// Convert packed signed 32-bit integers in \a __A to packed 8-bit integers
+///    with symmetric signed saturation, using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVSSDB instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector of [4 x i32].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtss_epi32_epi8(__m128i __W, __mmask8 __U, __m128i __A) {
+  return (__m128i)__builtin_ia32_vpmovssdb128_mask((__v4si)__A, (__v16qi)__W,
+                                                   __U);
+}
+
+/// Convert packed signed 32-bit integers in \a __A to packed 8-bit integers
+///    with symmetric signed saturation, using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVSSDB instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 128-bit vector of [4 x i32].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtss_epi32_epi8(__mmask8 __U, __m128i __A) {
+  return (__m128i)__builtin_ia32_vpmovssdb128_mask(
+      (__v4si)__A, (__v16qi)_mm_setzero_si128(), __U);
+}
+
+/// Convert packed signed 32-bit integers in \a __A to packed 8-bit integers
+///    with symmetric signed saturation (clamp to [-127, +127]), and store
+///    the results in a 128-bit vector.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVSSDB instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x i32].
+/// \returns
+///    A 128-bit vector of [16 x i8]. The lower 8 bytes contain the converted
+///    values; the upper bytes are zeroed.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtss_epi32_epi8(__m256i __A) {
+  return (__m128i)__builtin_ia32_vpmovssdb256_mask(
+      (__v8si)__A, (__v16qi)_mm_setzero_si128(), (__mmask8)-1);
+}
+
+/// Convert packed signed 32-bit integers in \a __A to packed 8-bit integers
+///    with symmetric signed saturation, using writemask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVSSDB instruction.
+///
+/// \param __W
+///    A 128-bit vector of [16 x i8] used for writemask.
+/// \param __U
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 256-bit vector of [8 x i32].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtss_epi32_epi8(__m128i __W, __mmask8 __U, __m256i __A) {
+  return (__m128i)__builtin_ia32_vpmovssdb256_mask((__v8si)__A, (__v16qi)__W,
+                                                   __U);
+}
+
+/// Convert packed signed 32-bit integers in \a __A to packed 8-bit integers
+///    with symmetric signed saturation, using zeromask \a __U.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVSSDB instruction.
+///
+/// \param __U
+///    A 8-bit mask indicating which elements to write (zero otherwise).
+/// \param __A
+///    A 256-bit vector of [8 x i32].
+/// \returns
+///    A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtss_epi32_epi8(__mmask8 __U, __m256i __A) {
+  return (__m128i)__builtin_ia32_vpmovssdb256_mask(
+      (__v8si)__A, (__v16qi)_mm_setzero_si128(), __U);
+}
+
+/// Truncate packed 32-bit integers in \a __A to packed 8-bit integers with
+/// symmetric signed saturation, and store the results to memory at \a __P
+/// using writemask \a __M (elements not selected by the mask are not written).
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVSSDB instruction.
+///
+/// \param __P
+///    Pointer to the destination memory.
+/// \param __M
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 128-bit vector of [4 x i32].
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtss_epi32_storeu_epi8(void *__P, __mmask8 __M, __m128i __A) {
+  __builtin_ia32_vpmovssdb128mem_mask((__v16qi *)__P, (__v4si)__A, __M);
+}
+
+/// Truncate packed 32-bit integers in \a __A to packed 8-bit integers with
+/// symmetric signed saturation, and store the results to memory at \a __P
+/// using writemask \a __M (elements not selected by the mask are not written).
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVSSDB instruction.
+///
+/// \param __P
+///    Pointer to the destination memory.
+/// \param __M
+///    A 8-bit mask indicating which elements to write.
+/// \param __A
+///    A 256-bit vector of [8 x i32].
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtss_epi32_storeu_epi8(void *__P, __mmask8 __M, __m256i __A) {
+  __builtin_ia32_vpmovssdb256mem_mask((__v16qi *)__P, (__v8si)__A, __M);
+}
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif // __AVX10V2AUXINTRIN_H
+#endif // __SSE2__