# Intrinsics for Comparison Operations

The prototypes for Intel® Advanced Vector Extensions 512 (Intel® AVX-512) intrinsics are located in the zmmintrin.h header file.
To use these intrinsics, include the immintrin.h file as follows:

    #include <immintrin.h>

variable | definition
--- | ---
src | source element to use based on writemask result
k | writemask used as a selector
a | first source vector element
b | second source vector element
imm | comparison predicate, which can be any of the following values: `_MM_CMPINT_EQ` - Equal `_MM_CMPINT_LT` - Less than `_MM_CMPINT_LE` - Less than or Equal `_MM_CMPINT_NE` - Not Equal `_MM_CMPINT_NLT` - Not Less than `_MM_CMPINT_GE` - Greater than or Equal `_MM_CMPINT_NLE` - Not Less than or Equal `_MM_CMPINT_GT` - Greater than

_mm_conflict_epi32

    __m128i _mm_conflict_epi32(__m128i a)

CPUID Flags: AVX512CD, AVX512VL

Instruction(s): vpconflictd

Test each 32-bit element of a for equality with all other elements in a closer to the least significant element. Each element's comparison forms a zero extended bit vector in the return value.

_mm_mask_conflict_epi32

    __m128i _mm_mask_conflict_epi32(__m128i src, __mmask8 k, __m128i a)

CPUID Flags: AVX512CD, AVX512VL

Instruction(s): vpconflictd

Test each 32-bit element of a for equality with all other elements in a closer to the least significant element using writemask k (elements are copied from src when the corresponding mask bit is not set). Each element's comparison forms a zero extended bit vector in the return value.

_mm_maskz_conflict_epi32

    __m128i _mm_maskz_conflict_epi32(__mmask8 k, __m128i a)

CPUID Flags: AVX512CD, AVX512VL

Instruction(s): vpconflictd

Test each 32-bit element of a for equality with all other elements in a closer to the least significant element using zeromask k (elements are zeroed out when the corresponding mask bit is not set). Each element's comparison forms a zero extended bit vector in the return value.

_mm256_conflict_epi32

    __m256i _mm256_conflict_epi32(__m256i a)

CPUID Flags: AVX512CD, AVX512VL

Instruction(s): vpconflictd

Test each 32-bit element of a for equality with all other elements in a closer to the least significant element. Each element's comparison forms a zero extended bit vector in the return value.

_mm256_mask_conflict_epi32

    __m256i _mm256_mask_conflict_epi32(__m256i src, __mmask8 k, __m256i a)

CPUID Flags: AVX512CD, AVX512VL

Instruction(s): vpconflictd

Test each 32-bit element of a for equality with all other elements in a closer to the least significant element using writemask k (elements are copied from src when the corresponding mask bit is not set). Each element's comparison forms a zero extended bit vector in the return value.

_mm256_maskz_conflict_epi32

    __m256i _mm256_maskz_conflict_epi32(__mmask8 k, __m256i a)

CPUID Flags: AVX512CD, AVX512VL

Instruction(s): vpconflictd

Test each 32-bit element of a for equality with all other elements in a closer to the least significant element using zeromask k (elements are zeroed out when the corresponding mask bit is not set). Each element's comparison forms a zero extended bit vector in the return value.

_mm_conflict_epi64

    __m128i _mm_conflict_epi64(__m128i a)

CPUID Flags: AVX512CD, AVX512VL

Instruction(s): vpconflictq

Test each 64-bit element of a for equality with all other elements in a closer to the least significant element. Each element's comparison forms a zero extended bit vector in the return value.

_mm_mask_conflict_epi64

    __m128i _mm_mask_conflict_epi64(__m128i src, __mmask8 k, __m128i a)

CPUID Flags: AVX512CD, AVX512VL

Instruction(s): vpconflictq

Test each 64-bit element of a for equality with all other elements in a closer to the least significant element using writemask k (elements are copied from src when the corresponding mask bit is not set). Each element's comparison forms a zero extended bit vector in the return value.

_mm_maskz_conflict_epi64

    __m128i _mm_maskz_conflict_epi64(__mmask8 k, __m128i a)

CPUID Flags: AVX512CD, AVX512VL

Instruction(s): vpconflictq

Test each 64-bit element of a for equality with all other elements in a closer to the least significant element using zeromask k (elements are zeroed out when the corresponding mask bit is not set). Each element's comparison forms a zero extended bit vector in the return value.

_mm256_conflict_epi64

    __m256i _mm256_conflict_epi64(__m256i a)

CPUID Flags: AVX512CD, AVX512VL

Instruction(s): vpconflictq

Test each 64-bit element of a for equality with all other elements in a closer to the least significant element. Each element's comparison forms a zero extended bit vector in the return value.

_mm256_mask_conflict_epi64

    __m256i _mm256_mask_conflict_epi64(__m256i src, __mmask8 k, __m256i a)

CPUID Flags: AVX512CD, AVX512VL

Instruction(s): vpconflictq

Test each 64-bit element of a for equality with all other elements in a closer to the least significant element using writemask k (elements are copied from src when the corresponding mask bit is not set). Each element's comparison forms a zero extended bit vector in the return value.

_mm256_maskz_conflict_epi64

    __m256i _mm256_maskz_conflict_epi64(__mmask8 k, __m256i a)

CPUID Flags: AVX512CD, AVX512VL

Instruction(s): vpconflictq

Test each 64-bit element of a for equality with all other elements in a closer to the least significant element using zeromask k (elements are zeroed out when the corresponding mask bit is not set). Each element's comparison forms a zero extended bit vector in the return value.

_mm_cmp_pd_mask

    __mmask8 _mm_cmp_pd_mask(__m128d a, __m128d b, const int imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vcmppd

Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm_mask_cmp_pd_mask

    __mmask8 _mm_mask_cmp_pd_mask(__mmask8 k1, __m128d a, __m128d b, const int imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vcmppd

Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm256_cmp_pd_mask

    __mmask8 _mm256_cmp_pd_mask(__m256d a, __m256d b, const int imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vcmppd

Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm256_mask_cmp_pd_mask

    __mmask8 _mm256_mask_cmp_pd_mask(__mmask8 k1, __m256d a, __m256d b, const int imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vcmppd

Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm_cmp_ps_mask

    __mmask8 _mm_cmp_ps_mask(__m128 a, __m128 b, const int imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vcmpps

Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm_mask_cmp_ps_mask

    __mmask8 _mm_mask_cmp_ps_mask(__mmask8 k1, __m128 a, __m128 b, const int imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vcmpps

Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm256_cmp_ps_mask

    __mmask8 _mm256_cmp_ps_mask(__m256 a, __m256 b, const int imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vcmpps

Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm256_mask_cmp_ps_mask

    __mmask8 _mm256_mask_cmp_ps_mask(__mmask8 k1, __m256 a, __m256 b, const int imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vcmpps

Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm_cmp_epi8_mask

    __mmask16 _mm_cmp_epi8_mask(__m128i a, __m128i b, const int imm)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpeq_epi8_mask

    __mmask16 _mm_cmpeq_epi8_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpge_epi8_mask

    __mmask16 _mm_cmpge_epi8_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpgt_epi8_mask

    __mmask16 _mm_cmpgt_epi8_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm_cmple_epi8_mask

    __mmask16 _mm_cmple_epi8_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_cmplt_epi8_mask

    __mmask16 _mm_cmplt_epi8_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpneq_epi8_mask

    __mmask16 _mm_cmpneq_epi8_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_mask_cmp_epi8_mask

    __mmask16 _mm_mask_cmp_epi8_mask(__mmask16 k1, __m128i a, __m128i b, const int imm)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpeq_epi8_mask

    __mmask16 _mm_mask_cmpeq_epi8_mask(__mmask16 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpge_epi8_mask

    __mmask16 _mm_mask_cmpge_epi8_mask(__mmask16 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpgt_epi8_mask

    __mmask16 _mm_mask_cmpgt_epi8_mask(__mmask16 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmple_epi8_mask

    __mmask16 _mm_mask_cmple_epi8_mask(__mmask16 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmplt_epi8_mask

    __mmask16 _mm_mask_cmplt_epi8_mask(__mmask16 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpneq_epi8_mask

    __mmask16 _mm_mask_cmpneq_epi8_mask(__mmask16 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm256_cmp_epi8_mask

    __mmask32 _mm256_cmp_epi8_mask(__m256i a, __m256i b, const int imm)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpeq_epi8_mask

    __mmask32 _mm256_cmpeq_epi8_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpge_epi8_mask

    __mmask32 _mm256_cmpge_epi8_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpgt_epi8_mask

    __mmask32 _mm256_cmpgt_epi8_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmple_epi8_mask

    __mmask32 _mm256_cmple_epi8_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmplt_epi8_mask

    __mmask32 _mm256_cmplt_epi8_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpneq_epi8_mask

    __mmask32 _mm256_cmpneq_epi8_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_mask_cmp_epi8_mask

    __mmask32 _mm256_mask_cmp_epi8_mask(__mmask32 k1, __m256i a, __m256i b, const int imm)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpeq_epi8_mask

    __mmask32 _mm256_mask_cmpeq_epi8_mask(__mmask32 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpge_epi8_mask

    __mmask32 _mm256_mask_cmpge_epi8_mask(__mmask32 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpgt_epi8_mask

    __mmask32 _mm256_mask_cmpgt_epi8_mask(__mmask32 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmple_epi8_mask

    __mmask32 _mm256_mask_cmple_epi8_mask(__mmask32 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmplt_epi8_mask

    __mmask32 _mm256_mask_cmplt_epi8_mask(__mmask32 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpneq_epi8_mask

    __mmask32 _mm256_mask_cmpneq_epi8_mask(__mmask32 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm512_cmp_epi8_mask

    __mmask64 _mm512_cmp_epi8_mask(__m512i a, __m512i b, const int imm)

CPUID Flags: AVX512BW

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmpeq_epi8_mask

    __mmask64 _mm512_cmpeq_epi8_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmpge_epi8_mask

    __mmask64 _mm512_cmpge_epi8_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmpgt_epi8_mask

    __mmask64 _mm512_cmpgt_epi8_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmple_epi8_mask

    __mmask64 _mm512_cmple_epi8_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmplt_epi8_mask

    __mmask64 _mm512_cmplt_epi8_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmpneq_epi8_mask

    __mmask64 _mm512_cmpneq_epi8_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm512_mask_cmp_epi8_mask

    __mmask64 _mm512_mask_cmp_epi8_mask(__mmask64 k1, __m512i a, __m512i b, const int imm)

CPUID Flags: AVX512BW

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmpeq_epi8_mask

    __mmask64 _mm512_mask_cmpeq_epi8_mask(__mmask64 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmpge_epi8_mask

    __mmask64 _mm512_mask_cmpge_epi8_mask(__mmask64 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmpgt_epi8_mask

    __mmask64 _mm512_mask_cmpgt_epi8_mask(__mmask64 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmple_epi8_mask

    __mmask64 _mm512_mask_cmple_epi8_mask(__mmask64 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmplt_epi8_mask

    __mmask64 _mm512_mask_cmplt_epi8_mask(__mmask64 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmpneq_epi8_mask

    __mmask64 _mm512_mask_cmpneq_epi8_mask(__mmask64 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpb

Compare packed 8-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm_cmp_epi32_mask

    __mmask8 _mm_cmp_epi32_mask(__m128i a, __m128i b, const _MM_CMPINT_ENUM imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpeq_epi32_mask

    __mmask8 _mm_cmpeq_epi32_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpge_epi32_mask

    __mmask8 _mm_cmpge_epi32_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpgt_epi32_mask

    __mmask8 _mm_cmpgt_epi32_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm_cmple_epi32_mask

    __mmask8 _mm_cmple_epi32_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_cmplt_epi32_mask

    __mmask8 _mm_cmplt_epi32_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpneq_epi32_mask

    __mmask8 _mm_cmpneq_epi32_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_mask_cmp_epi32_mask

    __mmask8 _mm_mask_cmp_epi32_mask(__mmask8 k1, __m128i a, __m128i b, const _MM_CMPINT_ENUM imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpeq_epi32_mask

    __mmask8 _mm_mask_cmpeq_epi32_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpge_epi32_mask

    __mmask8 _mm_mask_cmpge_epi32_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpgt_epi32_mask

    __mmask8 _mm_mask_cmpgt_epi32_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmple_epi32_mask

    __mmask8 _mm_mask_cmple_epi32_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmplt_epi32_mask

    __mmask8 _mm_mask_cmplt_epi32_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpneq_epi32_mask

    __mmask8 _mm_mask_cmpneq_epi32_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_cmp_epi32_mask

    __mmask8 _mm256_cmp_epi32_mask(__m256i a, __m256i b, const _MM_CMPINT_ENUM imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpeq_epi32_mask

    __mmask8 _mm256_cmpeq_epi32_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpge_epi32_mask

    __mmask8 _mm256_cmpge_epi32_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpgt_epi32_mask

    __mmask8 _mm256_cmpgt_epi32_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmple_epi32_mask

    __mmask8 _mm256_cmple_epi32_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmplt_epi32_mask

    __mmask8 _mm256_cmplt_epi32_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpneq_epi32_mask

    __mmask8 _mm256_cmpneq_epi32_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_mask_cmp_epi32_mask

    __mmask8 _mm256_mask_cmp_epi32_mask(__mmask8 k1, __m256i a, __m256i b, const _MM_CMPINT_ENUM imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpeq_epi32_mask

    __mmask8 _mm256_mask_cmpeq_epi32_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpge_epi32_mask

    __mmask8 _mm256_mask_cmpge_epi32_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpgt_epi32_mask

    __mmask8 _mm256_mask_cmpgt_epi32_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmple_epi32_mask

    __mmask8 _mm256_mask_cmple_epi32_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmplt_epi32_mask

    __mmask8 _mm256_mask_cmplt_epi32_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpneq_epi32_mask

    __mmask8 _mm256_mask_cmpneq_epi32_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpd

Compare packed 32-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_cmp_epi64_mask

    __mmask8 _mm_cmp_epi64_mask(__m128i a, __m128i b, const _MM_CMPINT_ENUM imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpeq_epi64_mask

    __mmask8 _mm_cmpeq_epi64_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpge_epi64_mask

    __mmask8 _mm_cmpge_epi64_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpgt_epi64_mask

    __mmask8 _mm_cmpgt_epi64_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm_cmple_epi64_mask

    __mmask8 _mm_cmple_epi64_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_cmplt_epi64_mask

    __mmask8 _mm_cmplt_epi64_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpneq_epi64_mask

    __mmask8 _mm_cmpneq_epi64_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_mask_cmp_epi64_mask

    __mmask8 _mm_mask_cmp_epi64_mask(__mmask8 k1, __m128i a, __m128i b, const _MM_CMPINT_ENUM imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpeq_epi64_mask

    __mmask8 _mm_mask_cmpeq_epi64_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpge_epi64_mask

    __mmask8 _mm_mask_cmpge_epi64_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpgt_epi64_mask

    __mmask8 _mm_mask_cmpgt_epi64_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmple_epi64_mask

    __mmask8 _mm_mask_cmple_epi64_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmplt_epi64_mask

    __mmask8 _mm_mask_cmplt_epi64_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpneq_epi64_mask

    __mmask8 _mm_mask_cmpneq_epi64_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_cmp_epi64_mask

    __mmask8 _mm256_cmp_epi64_mask(__m256i a, __m256i b, const _MM_CMPINT_ENUM imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpeq_epi64_mask

    __mmask8 _mm256_cmpeq_epi64_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpge_epi64_mask

    __mmask8 _mm256_cmpge_epi64_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpgt_epi64_mask

    __mmask8 _mm256_cmpgt_epi64_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmple_epi64_mask

    __mmask8 _mm256_cmple_epi64_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmplt_epi64_mask

    __mmask8 _mm256_cmplt_epi64_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpneq_epi64_mask

    __mmask8 _mm256_cmpneq_epi64_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_mask_cmp_epi64_mask

    __mmask8 _mm256_mask_cmp_epi64_mask(__mmask8 k1, __m256i a, __m256i b, const _MM_CMPINT_ENUM imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpeq_epi64_mask

    __mmask8 _mm256_mask_cmpeq_epi64_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpge_epi64_mask

    __mmask8 _mm256_mask_cmpge_epi64_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpgt_epi64_mask

    __mmask8 _mm256_mask_cmpgt_epi64_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmple_epi64_mask

    __mmask8 _mm256_mask_cmple_epi64_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmplt_epi64_mask

    __mmask8 _mm256_mask_cmplt_epi64_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpneq_epi64_mask

    __mmask8 _mm256_mask_cmpneq_epi64_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpq

Compare packed 64-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_cmp_epu8_mask

    __mmask16 _mm_cmp_epu8_mask(__m128i a, __m128i b, const int imm)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpeq_epu8_mask

    __mmask16 _mm_cmpeq_epu8_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpge_epu8_mask

    __mmask16 _mm_cmpge_epu8_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpgt_epu8_mask

    __mmask16 _mm_cmpgt_epu8_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm_cmple_epu8_mask

    __mmask16 _mm_cmple_epu8_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_cmplt_epu8_mask

    __mmask16 _mm_cmplt_epu8_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpneq_epu8_mask

    __mmask16 _mm_cmpneq_epu8_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_mask_cmp_epu8_mask

    __mmask16 _mm_mask_cmp_epu8_mask(__mmask16 k1, __m128i a, __m128i b, const int imm)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpeq_epu8_mask

    __mmask16 _mm_mask_cmpeq_epu8_mask(__mmask16 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpge_epu8_mask

    __mmask16 _mm_mask_cmpge_epu8_mask(__mmask16 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpgt_epu8_mask

    __mmask16 _mm_mask_cmpgt_epu8_mask(__mmask16 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmple_epu8_mask

    __mmask16 _mm_mask_cmple_epu8_mask(__mmask16 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmplt_epu8_mask

    __mmask16 _mm_mask_cmplt_epu8_mask(__mmask16 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpneq_epu8_mask

    __mmask16 _mm_mask_cmpneq_epu8_mask(__mmask16 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm256_cmp_epu8_mask

    __mmask32 _mm256_cmp_epu8_mask(__m256i a, __m256i b, const int imm)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpeq_epu8_mask

    __mmask32 _mm256_cmpeq_epu8_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpge_epu8_mask

    __mmask32 _mm256_cmpge_epu8_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpgt_epu8_mask

    __mmask32 _mm256_cmpgt_epu8_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmple_epu8_mask

    __mmask32 _mm256_cmple_epu8_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmplt_epu8_mask

    __mmask32 _mm256_cmplt_epu8_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpneq_epu8_mask

    __mmask32 _mm256_cmpneq_epu8_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_mask_cmp_epu8_mask

    __mmask32 _mm256_mask_cmp_epu8_mask(__mmask32 k1, __m256i a, __m256i b, const int imm)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpeq_epu8_mask

    __mmask32 _mm256_mask_cmpeq_epu8_mask(__mmask32 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpge_epu8_mask

    __mmask32 _mm256_mask_cmpge_epu8_mask(__mmask32 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpgt_epu8_mask

    __mmask32 _mm256_mask_cmpgt_epu8_mask(__mmask32 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmple_epu8_mask

    __mmask32 _mm256_mask_cmple_epu8_mask(__mmask32 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmplt_epu8_mask

    __mmask32 _mm256_mask_cmplt_epu8_mask(__mmask32 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpneq_epu8_mask

    __mmask32 _mm256_mask_cmpneq_epu8_mask(__mmask32 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm512_cmp_epu8_mask

    __mmask64 _mm512_cmp_epu8_mask(__m512i a, __m512i b, const int imm)

CPUID Flags: AVX512BW

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmpeq_epu8_mask

    __mmask64 _mm512_cmpeq_epu8_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmpge_epu8_mask

    __mmask64 _mm512_cmpge_epu8_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmpgt_epu8_mask

    __mmask64 _mm512_cmpgt_epu8_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmple_epu8_mask

    __mmask64 _mm512_cmple_epu8_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmplt_epu8_mask

    __mmask64 _mm512_cmplt_epu8_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmpneq_epu8_mask

    __mmask64 _mm512_cmpneq_epu8_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm512_mask_cmp_epu8_mask

    __mmask64 _mm512_mask_cmp_epu8_mask(__mmask64 k1, __m512i a, __m512i b, const int imm)

CPUID Flags: AVX512BW

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmpeq_epu8_mask

    __mmask64 _mm512_mask_cmpeq_epu8_mask(__mmask64 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmpge_epu8_mask

    __mmask64 _mm512_mask_cmpge_epu8_mask(__mmask64 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmpgt_epu8_mask

    __mmask64 _mm512_mask_cmpgt_epu8_mask(__mmask64 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmple_epu8_mask

    __mmask64 _mm512_mask_cmple_epu8_mask(__mmask64 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmplt_epu8_mask

    __mmask64 _mm512_mask_cmplt_epu8_mask(__mmask64 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmpneq_epu8_mask

    __mmask64 _mm512_mask_cmpneq_epu8_mask(__mmask64 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpub

Compare packed unsigned 8-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k1 (elements are zeroed out when the corresponding mask bit is not set).

_mm_cmp_epu32_mask

    __mmask8 _mm_cmp_epu32_mask(__m128i a, __m128i b, const _MM_CMPINT_ENUM imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpeq_epu32_mask

    __mmask8 _mm_cmpeq_epu32_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpge_epu32_mask

    __mmask8 _mm_cmpge_epu32_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpgt_epu32_mask

    __mmask8 _mm_cmpgt_epu32_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm_cmple_epu32_mask

    __mmask8 _mm_cmple_epu32_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_cmplt_epu32_mask

    __mmask8 _mm_cmplt_epu32_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpneq_epu32_mask

    __mmask8 _mm_cmpneq_epu32_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_mask_cmp_epu32_mask

    __mmask8 _mm_mask_cmp_epu32_mask(__mmask8 k1, __m128i a, __m128i b, const _MM_CMPINT_ENUM imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpeq_epu32_mask

    __mmask8 _mm_mask_cmpeq_epu32_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpge_epu32_mask

    __mmask8 _mm_mask_cmpge_epu32_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpgt_epu32_mask

    __mmask8 _mm_mask_cmpgt_epu32_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmple_epu32_mask

    __mmask8 _mm_mask_cmple_epu32_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmplt_epu32_mask

    __mmask8 _mm_mask_cmplt_epu32_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpneq_epu32_mask

    __mmask8 _mm_mask_cmpneq_epu32_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_cmp_epu32_mask

    __mmask8 _mm256_cmp_epu32_mask(__m256i a, __m256i b, const _MM_CMPINT_ENUM imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpeq_epu32_mask

    __mmask8 _mm256_cmpeq_epu32_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpge_epu32_mask

    __mmask8 _mm256_cmpge_epu32_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpgt_epu32_mask

    __mmask8 _mm256_cmpgt_epu32_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmple_epu32_mask

    __mmask8 _mm256_cmple_epu32_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmplt_epu32_mask

    __mmask8 _mm256_cmplt_epu32_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpneq_epu32_mask

    __mmask8 _mm256_cmpneq_epu32_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_mask_cmp_epu32_mask

    __mmask8 _mm256_mask_cmp_epu32_mask(__mmask8 k1, __m256i a, __m256i b, const _MM_CMPINT_ENUM imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpeq_epu32_mask

    __mmask8 _mm256_mask_cmpeq_epu32_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpge_epu32_mask

    __mmask8 _mm256_mask_cmpge_epu32_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpgt_epu32_mask

    __mmask8 _mm256_mask_cmpgt_epu32_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmple_epu32_mask

    __mmask8 _mm256_mask_cmple_epu32_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmplt_epu32_mask

    __mmask8 _mm256_mask_cmplt_epu32_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpneq_epu32_mask

    __mmask8 _mm256_mask_cmpneq_epu32_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpud

Compare packed unsigned 32-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_cmp_epu64_mask

    __mmask8 _mm_cmp_epu64_mask(__m128i a, __m128i b, const _MM_CMPINT_ENUM imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpeq_epu64_mask

    __mmask8 _mm_cmpeq_epu64_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpge_epu64_mask

    __mmask8 _mm_cmpge_epu64_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpgt_epu64_mask

    __mmask8 _mm_cmpgt_epu64_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm_cmple_epu64_mask

    __mmask8 _mm_cmple_epu64_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_cmplt_epu64_mask

    __mmask8 _mm_cmplt_epu64_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpneq_epu64_mask

    __mmask8 _mm_cmpneq_epu64_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_mask_cmp_epu64_mask

    __mmask8 _mm_mask_cmp_epu64_mask(__mmask8 k1, __m128i a, __m128i b, const _MM_CMPINT_ENUM imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpeq_epu64_mask

    __mmask8 _mm_mask_cmpeq_epu64_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpge_epu64_mask

    __mmask8 _mm_mask_cmpge_epu64_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpgt_epu64_mask

    __mmask8 _mm_mask_cmpgt_epu64_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmple_epu64_mask

    __mmask8 _mm_mask_cmple_epu64_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmplt_epu64_mask

    __mmask8 _mm_mask_cmplt_epu64_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpneq_epu64_mask

    __mmask8 _mm_mask_cmpneq_epu64_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_cmp_epu64_mask

    __mmask8 _mm256_cmp_epu64_mask(__m256i a, __m256i b, const _MM_CMPINT_ENUM imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpeq_epu64_mask

    __mmask8 _mm256_cmpeq_epu64_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpge_epu64_mask

    __mmask8 _mm256_cmpge_epu64_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpgt_epu64_mask

    __mmask8 _mm256_cmpgt_epu64_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmple_epu64_mask

    __mmask8 _mm256_cmple_epu64_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmplt_epu64_mask

    __mmask8 _mm256_cmplt_epu64_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpneq_epu64_mask

    __mmask8 _mm256_cmpneq_epu64_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_mask_cmp_epu64_mask

    __mmask8 _mm256_mask_cmp_epu64_mask(__mmask8 k1, __m256i a, __m256i b, const _MM_CMPINT_ENUM imm)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpeq_epu64_mask

    __mmask8 _mm256_mask_cmpeq_epu64_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpge_epu64_mask

    __mmask8 _mm256_mask_cmpge_epu64_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpgt_epu64_mask

    __mmask8 _mm256_mask_cmpgt_epu64_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmple_epu64_mask

    __mmask8 _mm256_mask_cmple_epu64_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmplt_epu64_mask

    __mmask8 _mm256_mask_cmplt_epu64_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpneq_epu64_mask

    __mmask8 _mm256_mask_cmpneq_epu64_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vpcmpuq

Compare packed unsigned 64-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_cmp_epu16_mask

    __mmask8 _mm_cmp_epu16_mask(__m128i a, __m128i b, const int imm)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpeq_epu16_mask

    __mmask8 _mm_cmpeq_epu16_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpge_epu16_mask

    __mmask8 _mm_cmpge_epu16_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpgt_epu16_mask

    __mmask8 _mm_cmpgt_epu16_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm_cmple_epu16_mask

    __mmask8 _mm_cmple_epu16_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_cmplt_epu16_mask

    __mmask8 _mm_cmplt_epu16_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpneq_epu16_mask

    __mmask8 _mm_cmpneq_epu16_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_mask_cmp_epu16_mask

    __mmask8 _mm_mask_cmp_epu16_mask(__mmask8 k1, __m128i a, __m128i b, const int imm)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpeq_epu16_mask

    __mmask8 _mm_mask_cmpeq_epu16_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpge_epu16_mask

    __mmask8 _mm_mask_cmpge_epu16_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpgt_epu16_mask

    __mmask8 _mm_mask_cmpgt_epu16_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmple_epu16_mask

    __mmask8 _mm_mask_cmple_epu16_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmplt_epu16_mask

    __mmask8 _mm_mask_cmplt_epu16_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpneq_epu16_mask

    __mmask8 _mm_mask_cmpneq_epu16_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_cmp_epu16_mask

    __mmask16 _mm256_cmp_epu16_mask(__m256i a, __m256i b, const int imm)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpeq_epu16_mask

    __mmask16 _mm256_cmpeq_epu16_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpge_epu16_mask

    __mmask16 _mm256_cmpge_epu16_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpgt_epu16_mask

    __mmask16 _mm256_cmpgt_epu16_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmple_epu16_mask

    __mmask16 _mm256_cmple_epu16_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmplt_epu16_mask

    __mmask16 _mm256_cmplt_epu16_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpneq_epu16_mask

    __mmask16 _mm256_cmpneq_epu16_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_mask_cmp_epu16_mask

    __mmask16 _mm256_mask_cmp_epu16_mask(__mmask16 k1, __m256i a, __m256i b, const int imm)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpeq_epu16_mask

    __mmask16 _mm256_mask_cmpeq_epu16_mask(__mmask16 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpge_epu16_mask

    __mmask16 _mm256_mask_cmpge_epu16_mask(__mmask16 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpgt_epu16_mask

    __mmask16 _mm256_mask_cmpgt_epu16_mask(__mmask16 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmple_epu16_mask

    __mmask16 _mm256_mask_cmple_epu16_mask(__mmask16 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmplt_epu16_mask

    __mmask16 _mm256_mask_cmplt_epu16_mask(__mmask16 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpneq_epu16_mask

    __mmask16 _mm256_mask_cmpneq_epu16_mask(__mmask16 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm512_cmp_epu16_mask

    __mmask32 _mm512_cmp_epu16_mask(__m512i a, __m512i b, const int imm)

CPUID Flags: AVX512BW

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmpeq_epu16_mask

    __mmask32 _mm512_cmpeq_epu16_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmpge_epu16_mask

    __mmask32 _mm512_cmpge_epu16_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmpgt_epu16_mask

    __mmask32 _mm512_cmpgt_epu16_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmple_epu16_mask

    __mmask32 _mm512_cmple_epu16_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmplt_epu16_mask

    __mmask32 _mm512_cmplt_epu16_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmpneq_epu16_mask

    __mmask32 _mm512_cmpneq_epu16_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm512_mask_cmp_epu16_mask

    __mmask32 _mm512_mask_cmp_epu16_mask(__mmask32 k1, __m512i a, __m512i b, const int imm)

CPUID Flags: AVX512BW

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmpeq_epu16_mask

    __mmask32 _mm512_mask_cmpeq_epu16_mask(__mmask32 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmpge_epu16_mask

    __mmask32 _mm512_mask_cmpge_epu16_mask(__mmask32 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmpgt_epu16_mask

    __mmask32 _mm512_mask_cmpgt_epu16_mask(__mmask32 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmple_epu16_mask

    __mmask32 _mm512_mask_cmple_epu16_mask(__mmask32 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmplt_epu16_mask

    __mmask32 _mm512_mask_cmplt_epu16_mask(__mmask32 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmpneq_epu16_mask

    __mmask32 _mm512_mask_cmpneq_epu16_mask(__mmask32 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpuw

Compare packed unsigned 16-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_cmp_epi16_mask

    __mmask8 _mm_cmp_epi16_mask(__m128i a, __m128i b, const int imm)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpeq_epi16_mask

    __mmask8 _mm_cmpeq_epi16_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpge_epi16_mask

    __mmask8 _mm_cmpge_epi16_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpgt_epi16_mask

    __mmask8 _mm_cmpgt_epi16_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm_cmple_epi16_mask

    __mmask8 _mm_cmple_epi16_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_cmplt_epi16_mask

    __mmask8 _mm_cmplt_epi16_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm_cmpneq_epi16_mask

    __mmask8 _mm_cmpneq_epi16_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm_mask_cmp_epi16_mask

    __mmask8 _mm_mask_cmp_epi16_mask(__mmask8 k1, __m128i a, __m128i b, const int imm)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpeq_epi16_mask

    __mmask8 _mm_mask_cmpeq_epi16_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpge_epi16_mask

    __mmask8 _mm_mask_cmpge_epi16_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpgt_epi16_mask

    __mmask8 _mm_mask_cmpgt_epi16_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmple_epi16_mask

    __mmask8 _mm_mask_cmple_epi16_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmplt_epi16_mask

    __mmask8 _mm_mask_cmplt_epi16_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_cmpneq_epi16_mask

    __mmask8 _mm_mask_cmpneq_epi16_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_cmp_epi16_mask

    __mmask16 _mm256_cmp_epi16_mask(__m256i a, __m256i b, const int imm)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpeq_epi16_mask

    __mmask16 _mm256_cmpeq_epi16_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpge_epi16_mask

    __mmask16 _mm256_cmpge_epi16_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpgt_epi16_mask

    __mmask16 _mm256_cmpgt_epi16_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmple_epi16_mask

    __mmask16 _mm256_cmple_epi16_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmplt_epi16_mask

    __mmask16 _mm256_cmplt_epi16_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm256_cmpneq_epi16_mask

    __mmask16 _mm256_cmpneq_epi16_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm256_mask_cmp_epi16_mask

    __mmask16 _mm256_mask_cmp_epi16_mask(__mmask16 k1, __m256i a, __m256i b, const int imm)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpeq_epi16_mask

    __mmask16 _mm256_mask_cmpeq_epi16_mask(__mmask16 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpge_epi16_mask

    __mmask16 _mm256_mask_cmpge_epi16_mask(__mmask16 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpgt_epi16_mask

    __mmask16 _mm256_mask_cmpgt_epi16_mask(__mmask16 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmple_epi16_mask

    __mmask16 _mm256_mask_cmple_epi16_mask(__mmask16 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmplt_epi16_mask

    __mmask16 _mm256_mask_cmplt_epi16_mask(__mmask16 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm256_mask_cmpneq_epi16_mask

    __mmask16 _mm256_mask_cmpneq_epi16_mask(__mmask16 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm512_cmp_epi16_mask

    __mmask32 _mm512_cmp_epi16_mask(__m512i a, __m512i b, const int imm)

CPUID Flags: AVX512BW

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmpeq_epi16_mask

    __mmask32 _mm512_cmpeq_epi16_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmpge_epi16_mask

    __mmask32 _mm512_cmpge_epi16_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmpgt_epi16_mask

    __mmask32 _mm512_cmpgt_epi16_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmple_epi16_mask

    __mmask32 _mm512_cmple_epi16_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmplt_epi16_mask

    __mmask32 _mm512_cmplt_epi16_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value.

_mm512_cmpneq_epi16_mask

    __mmask32 _mm512_cmpneq_epi16_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value.

_mm512_mask_cmp_epi16_mask

    __mmask32 _mm512_mask_cmp_epi16_mask(__mmask32 k1, __m512i a, __m512i b, const int imm)

CPUID Flags: AVX512BW

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b based on the comparison operand specified by imm, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmpeq_epi16_mask

    __mmask32 _mm512_mask_cmpeq_epi16_mask(__mmask32 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for equality, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmpge_epi16_mask

    __mmask32 _mm512_mask_cmpge_epi16_mask(__mmask32 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for greater-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmpgt_epi16_mask

    __mmask32 _mm512_mask_cmpgt_epi16_mask(__mmask32 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for greater-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmple_epi16_mask

    __mmask32 _mm512_mask_cmple_epi16_mask(__mmask32 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for less-than-or-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmplt_epi16_mask

    __mmask32 _mm512_mask_cmplt_epi16_mask(__mmask32 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for less-than, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm512_mask_cmpneq_epi16_mask

    __mmask32 _mm512_mask_cmpneq_epi16_mask(__mmask32 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vpcmpw

Compare packed 16-bit integers in a and b for not-equal, and and put each result in the corresponding bit of the returned mask value using zeromask k (elements are zeroed out when the corresponding mask bit is not set).

_mm_mask_test_epi8_mask

    __mmask16 _mm_mask_test_epi8_mask(__mmask16 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vptestmb

Compute the bitwise AND of packed 8-bit integers in a and b, producing intermediate 8-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is non-zero.

_mm_test_epi8_mask

    __mmask16 _mm_test_epi8_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vptestmb

Compute the bitwise AND of packed 8-bit integers in a and b, producing intermediate 8-bit values, and set the corresponding bit in the returned mask value if the intermediate value is non-zero.

_mm256_mask_test_epi8_mask

    __mmask32 _mm256_mask_test_epi8_mask(__mmask32 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vptestmb

Compute the bitwise AND of packed 8-bit integers in a and b, producing intermediate 8-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is non-zero.

_mm256_test_epi8_mask

    __mmask32 _mm256_test_epi8_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vptestmb

Compute the bitwise AND of packed 8-bit integers in a and b, producing intermediate 8-bit values, and set the corresponding bit in the returned mask value if the intermediate value is non-zero.

_mm512_mask_test_epi8_mask

    __mmask64 _mm512_mask_test_epi8_mask(__mmask64 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vptestmb

Compute the bitwise AND of packed 8-bit integers in a and b, producing intermediate 8-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is non-zero.

_mm512_test_epi8_mask

    __mmask64 _mm512_test_epi8_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vptestmb

Compute the bitwise AND of packed 8-bit integers in a and b, producing intermediate 8-bit values, and set the corresponding bit in the returned mask value if the intermediate value is non-zero.

_mm_mask_test_epi32_mask

    __mmask8 _mm_mask_test_epi32_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vptestmd

Compute the bitwise AND of packed 32-bit integers in a and b, producing intermediate 32-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is non-zero.

_mm_test_epi32_mask

    __mmask8 _mm_test_epi32_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vptestmd

Compute the bitwise AND of packed 32-bit integers in a and b, producing intermediate 32-bit values, and set the corresponding bit in the returned mask value if the intermediate value is non-zero.

_mm256_mask_test_epi32_mask

    __mmask8 _mm256_mask_test_epi32_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vptestmd

Compute the bitwise AND of packed 32-bit integers in a and b, producing intermediate 32-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is non-zero.

_mm256_test_epi32_mask

    __mmask8 _mm256_test_epi32_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vptestmd

Compute the bitwise AND of packed 32-bit integers in a and b, producing intermediate 32-bit values, and set the corresponding bit in the returned mask value if the intermediate value is non-zero.

_mm_mask_test_epi64_mask

    __mmask8 _mm_mask_test_epi64_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vptestmq

Compute the bitwise AND of packed 64-bit integers in a and b, producing intermediate 64-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is non-zero.

_mm_test_epi64_mask

    __mmask8 _mm_test_epi64_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vptestmq

Compute the bitwise AND of packed 64-bit integers in a and b, producing intermediate 64-bit values, and set the corresponding bit in the returned mask value if the intermediate value is non-zero.

_mm256_mask_test_epi64_mask

    __mmask8 _mm256_mask_test_epi64_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vptestmq

Compute the bitwise AND of packed 64-bit integers in a and b, producing intermediate 64-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is non-zero.

_mm256_test_epi64_mask

    __mmask8 _mm256_test_epi64_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vptestmq

Compute the bitwise AND of packed 64-bit integers in a and b, producing intermediate 64-bit values, and set the corresponding bit in the returned mask value if the intermediate value is non-zero.

_mm_mask_test_epi16_mask

    __mmask8 _mm_mask_test_epi16_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vptestmw

Compute the bitwise AND of packed 16-bit integers in a and b, producing intermediate 16-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is non-zero.

_mm_test_epi16_mask

    __mmask8 _mm_test_epi16_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vptestmw

Compute the bitwise AND of packed 16-bit integers in a and b, producing intermediate 16-bit values, and set the corresponding bit in the returned mask value if the intermediate value is non-zero.

_mm256_mask_test_epi16_mask

    __mmask16 _mm256_mask_test_epi16_mask(__mmask16 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vptestmw

Compute the bitwise AND of packed 16-bit integers in a and b, producing intermediate 16-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is non-zero.

_mm256_test_epi16_mask

    __mmask16 _mm256_test_epi16_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vptestmw

Compute the bitwise AND of packed 16-bit integers in a and b, producing intermediate 16-bit values, and set the corresponding bit in the returned mask value if the intermediate value is non-zero.

_mm512_mask_test_epi16_mask

    __mmask32 _mm512_mask_test_epi16_mask(__mmask32 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vptestmw

Compute the bitwise AND of packed 16-bit integers in a and b, producing intermediate 16-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is non-zero.

_mm512_test_epi16_mask

    __mmask32 _mm512_test_epi16_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vptestmw

Compute the bitwise AND of packed 16-bit integers in a and b, producing intermediate 16-bit values, and set the corresponding bit in the returned mask value if the intermediate value is non-zero.

_mm_mask_testn_epi8_mask

    __mmask16 _mm_mask_testn_epi8_mask(__mmask16 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vptestnmb

Compute the bitwise AND of packed 8-bit integers in a and b, producing intermediate 8-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is zero.

_mm_testn_epi8_mask

    __mmask16 _mm_testn_epi8_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vptestnmb

Compute the bitwise AND of packed 8-bit integers in a and b, producing intermediate 8-bit values, and set the corresponding bit in the returned mask value if the intermediate value is zero.

_mm256_mask_testn_epi8_mask

    __mmask32 _mm256_mask_testn_epi8_mask(__mmask32 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vptestnmb

Compute the bitwise AND of packed 8-bit integers in a and b, producing intermediate 8-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is zero.

_mm256_testn_epi8_mask

    __mmask32 _mm256_testn_epi8_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vptestnmb

Compute the bitwise AND of packed 8-bit integers in a and b, producing intermediate 8-bit values, and set the corresponding bit in the returned mask value if the intermediate value is zero.

_mm512_mask_testn_epi8_mask

    __mmask64 _mm512_mask_testn_epi8_mask(__mmask64 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vptestnmb

Compute the bitwise AND of packed 8-bit integers in a and b, producing intermediate 8-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is zero.

_mm512_testn_epi8_mask

    __mmask64 _mm512_testn_epi8_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vptestnmb

Compute the bitwise AND of packed 8-bit integers in a and b, producing intermediate 8-bit values, and set the corresponding bit in the returned mask value if the intermediate value is zero.

_mm_mask_testn_epi32_mask

    __mmask8 _mm_mask_testn_epi32_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vptestnmd

Compute the bitwise AND of packed 32-bit integers in a and b, producing intermediate 32-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is zero.

_mm_testn_epi32_mask

    __mmask8 _mm_testn_epi32_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vptestnmd

Compute the bitwise AND of packed 32-bit integers in a and b, producing intermediate 32-bit values, and set the corresponding bit in the returned mask value if the intermediate value is zero.

_mm256_mask_testn_epi32_mask

    __mmask8 _mm256_mask_testn_epi32_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vptestnmd

Compute the bitwise AND of packed 32-bit integers in a and b, producing intermediate 32-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is zero.

_mm256_testn_epi32_mask

    __mmask8 _mm256_testn_epi32_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vptestnmd

Compute the bitwise AND of packed 32-bit integers in a and b, producing intermediate 32-bit values, and set the corresponding bit in the returned mask value if the intermediate value is zero.

_mm_mask_testn_epi64_mask

    __mmask8 _mm_mask_testn_epi64_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vptestnmq

Compute the bitwise AND of packed 64-bit integers in a and b, producing intermediate 64-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is zero.

_mm_testn_epi64_mask

    __mmask8 _mm_testn_epi64_mask(__m128i a, __m128i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vptestnmq

Compute the bitwise AND of packed 64-bit integers in a and b, producing intermediate 64-bit values, and set the corresponding bit in the returned mask value if the intermediate value is zero.

_mm256_mask_testn_epi64_mask

    __mmask8 _mm256_mask_testn_epi64_mask(__mmask8 k1, __m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vptestnmq

Compute the bitwise AND of packed 64-bit integers in a and b, producing intermediate 64-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is zero.

_mm256_testn_epi64_mask

    __mmask8 _mm256_testn_epi64_mask(__m256i a, __m256i b)

CPUID Flags: AVX512F, AVX512VL

Instruction(s): vptestnmq

Compute the bitwise AND of packed 64-bit integers in a and b, producing intermediate 64-bit values, and set the corresponding bit in the returned mask value if the intermediate value is zero.

_mm_mask_testn_epi16_mask

    __mmask8 _mm_mask_testn_epi16_mask(__mmask8 k1, __m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vptestnmw

Compute the bitwise AND of packed 16-bit integers in a and b, producing intermediate 16-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is zero.

_mm_testn_epi16_mask

    __mmask8 _mm_testn_epi16_mask(__m128i a, __m128i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vptestnmw

Compute the bitwise AND of packed 16-bit integers in a and b, producing intermediate 16-bit values, and set the corresponding bit in the returned mask value if the intermediate value is zero.

_mm256_mask_testn_epi16_mask

    __mmask16 _mm256_mask_testn_epi16_mask(__mmask16 k1, __m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vptestnmw

Compute the bitwise AND of packed 16-bit integers in a and b, producing intermediate 16-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is zero.

_mm256_testn_epi16_mask

    __mmask16 _mm256_testn_epi16_mask(__m256i a, __m256i b)

CPUID Flags: AVX512BW, AVX512VL

Instruction(s): vptestnmw

Compute the bitwise AND of packed 16-bit integers in a and b, producing intermediate 16-bit values, and set the corresponding bit in the returned mask value if the intermediate value is zero.

_mm512_mask_testn_epi16_mask

    __mmask32 _mm512_mask_testn_epi16_mask(__mmask32 k1, __m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vptestnmw

Compute the bitwise AND of packed 16-bit integers in a and b, producing intermediate 16-bit values, and set the corresponding bit in the returned mask value (subject to writemask k) if the intermediate value is zero.

_mm512_testn_epi16_mask

    __mmask32 _mm512_testn_epi16_mask(__m512i a, __m512i b)

CPUID Flags: AVX512BW

Instruction(s): vptestnmw

Compute the bitwise AND of packed 16-bit integers in a and b, producing intermediate 16-bit values, and set the corresponding bit in the returned mask value if the intermediate value is zero.

Parent topic: Intrinsics for Intel® Advanced Vector Extensions 512 (Intel® AVX-512) Additional Instructions