==============================================================================

==============================================================================

==============================================================================

==============================================================================

Compute the absolute value of packed signed 16-bit integers in a, and store the unsigned results in dst. https://www.intel.com/content/www/us/en/docs/

Compute the absolute value of packed signed 32-bit integers in a, and store the unsigned results in dst. https://www.intel.com/content/www/us/en/docs/

Compute the absolute value of packed signed 8-bit integers in a, and store the unsigned results in dst. https://www.intel.com/content/www/us/en/docs/i

Compute the absolute value of packed signed 16-bit integers in a, and store the unsigned results in dst. https://www.intel.com/content/www/us/en/docs/

Compute the absolute value of packed signed 32-bit integers in a, and store the unsigned results in dst. https://www.intel.com/content/www/us/en/docs/

Compute the absolute value of packed signed 8-bit integers in a, and store the unsigned results in dst. https://www.intel.com/content/www/us/en/docs/i

Add packed 16-bit integers in a and b, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm

Add packed 32-bit integers in a and b, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm

Add packed 64-bit integers in a and b, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm

Add packed 8-bit integers in a and b, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_

Add the lower double-precision (64-bit) floating-point element in a and b, store the result in the lower element of dst, and copy the upper element fr

Add 64-bit integers a and b, and store the result in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_add_si64

Add packed signed 16-bit integers in a and b using saturation, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-g

Add packed signed 8-bit integers in a and b using saturation, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-gu

Add packed unsigned 16-bit integers in a and b using saturation, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics

Add packed unsigned 8-bit integers in a and b using saturation, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-

Alternatively add and subtract packed double-precision (64-bit) floating-point elements in a to/from packed elements in b, and store the results in ds

Alternatively add and subtract packed single-precision (32-bit) floating-point elements in a to/from packed elements in b, and store the results in ds

Perform one round of an AES decryption flow on data (state) in a using the round key in RoundKey, and store the result in dst. https://www.intel.com/c

Perform the last round of an AES decryption flow on data (state) in a using the round key in RoundKey, and store the result in dst. https://www.intel.

In the absence of crypto extensions, implement aesenc using regular NEON intrinsics instead. See: https://www.workofard.com/2017/01/accelerated-aes-fo

Perform the last round of an AES encryption flow on data (state) in a using the round key in RoundKey, and store the result in dst. https://www.intel.

Perform the InvMixColumns transformation on a and store the result in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#te

Assist in expanding the AES cipher key by computing steps towards generating a round key for encryption cipher using data from a and an 8-bit round co

Compute the bitwise NOT of 128 bits (representing integer data) in a and then AND with b, and store the result in dst. https://www.intel.com/content/w

Average packed unsigned 16-bit integers in a and b, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.

Average packed unsigned 8-bit integers in a and b, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.h

Average packed unsigned 16-bit integers in a and b, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.

Average packed unsigned 8-bit integers in a and b, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.h

Blend packed single-precision (32-bit) floating-point elements from a and b using mask, and store the results in dst. https://www.intel.com/content/ww

Blend packed 8-bit integers from a and b using mask, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index

Blend packed double-precision (64-bit) floating-point elements from a and b using mask, and store the results in dst. https://www.intel.com/content/ww

Blend packed single-precision (32-bit) floating-point elements from a and b using mask, and store the results in dst. https://www.intel.com/content/ww

Cast vector of type __m128d to type __m128. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero laten

Cast vector of type __m128d to type __m128i. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero late

Cast vector of type __m128 to type __m128d. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero laten

Cast vector of type __m128 to type __m128i. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero laten

Cast vector of type __m128i to type __m128. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero laten

Round the lower double-precision (64-bit) floating-point element in b up to an integer value, store the result as a double-precision floating-point el

Round the lower single-precision (32-bit) floating-point element in b up to an integer value, store the result as a single-precision floating-point el

Perform a carry-less multiplication of two 64-bit integers, selected from a and b according to imm8, and store the results in dst. https://www.intel.c

Compare packed 16-bit integers in a and b for equality, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/in

Compare packed 32-bit integers in a and b for equality, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/in

Compare packed 64-bit integers in a and b for equality, and store the results in dst

Compare packed 8-bit integers in a and b for equality, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/ind

Compare the lower double-precision (64-bit) floating-point elements in a and b for equality, store the result in the lower element of dst, and copy th

Compare the lower single-precision (32-bit) floating-point elements in a and b for equality, store the result in the lower element of dst, and copy th

Compare packed strings in a and b with lengths la and lb using the control in imm8, and returns 1 if b did not contain a null character and the result

Compare packed strings in a and b with lengths la and lb using the control in imm8, and returns 1 if the resulting mask was non-zero, and 0 otherwise.

Compare packed strings in a and b with lengths la and lb using the control in imm8, and store the generated index in dst. https://www.intel.com/conten

Compare packed strings in a and b with lengths la and lb using the control in imm8, and store the generated mask in dst. https://www.intel.com/content

Compare packed strings in a and b with lengths la and lb using the control in imm8, and returns bit 0 of the resulting bit mask. https://www.intel.com

Compare packed strings in a and b with lengths la and lb using the control in imm8, and returns 1 if any character in a was null, and 0 otherwise. htt

Compare packed strings in a and b with lengths la and lb using the control in imm8, and returns 1 if any character in b was null, and 0 otherwise. htt

Compare the lower double-precision (64-bit) floating-point elements in a and b for greater-than-or-equal, store the result in the lower element of dst

Compare the lower single-precision (32-bit) floating-point elements in a and b for greater-than-or-equal, store the result in the lower element of dst

Compare packed signed 16-bit integers in a and b for greater-than, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsi

Compare packed signed 32-bit integers in a and b for greater-than, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsi

Compares the 2 signed 64-bit integers in a and the 2 signed 64-bit integers in b for greater than.

Compare packed signed 8-bit integers in a and b for greater-than, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsic

Compare the lower double-precision (64-bit) floating-point elements in a and b for greater-than, store the result in the lower element of dst, and cop

Compare the lower single-precision (32-bit) floating-point elements in a and b for greater-than, store the result in the lower element of dst, and cop

Compare packed strings with implicit lengths in a and b using the control in imm8, and returns 1 if b did not contain a null character and the resulti

Compare packed strings with implicit lengths in a and b using the control in imm8, and returns 1 if the resulting mask was non-zero, and 0 otherwise.

Compare packed strings with implicit lengths in a and b using the control in imm8, and store the generated index in dst. https://www.intel.com/content

Compare packed strings with implicit lengths in a and b using the control in imm8, and store the generated mask in dst. https://www.intel.com/content/

Compare packed strings with implicit lengths in a and b using the control in imm8, and returns bit 0 of the resulting bit mask. https://www.intel.com/

Compare packed strings with implicit lengths in a and b using the control in imm8, and returns 1 if any character in a was null, and 0 otherwise. http

Compare packed strings with implicit lengths in a and b using the control in imm8, and returns 1 if any character in b was null, and 0 otherwise. http

Compare the lower double-precision (64-bit) floating-point elements in a and b for less-than-or-equal, store the result in the lower element of dst, a

Compare the lower single-precision (32-bit) floating-point elements in a and b for less-than-or-equal, store the result in the lower element of dst, a

Compare packed signed 8-bit integers in a and b for less-than, and store the results in dst. Note: This intrinsic emits the pcmpgtb instruction with t

Compare the lower double-precision (64-bit) floating-point elements in a and b for less-than, store the result in the lower element of dst, and copy t

Compare the lower single-precision (32-bit) floating-point elements in a and b for less-than, store the result in the lower element of dst, and copy t

Compare the lower double-precision (64-bit) floating-point elements in a and b for not-equal, store the result in the lower element of dst, and copy t

Compare the lower single-precision (32-bit) floating-point elements in a and b for not-equal, store the result in the lower element of dst, and copy t

Compare the lower double-precision (64-bit) floating-point elements in a and b for not-greater-than-or-equal, store the result in the lower element of

Compare the lower single-precision (32-bit) floating-point elements in a and b for not-greater-than-or-equal, store the result in the lower element of

Compare the lower double-precision (64-bit) floating-point elements in a and b for not-greater-than, store the result in the lower element of dst, and

Compare the lower single-precision (32-bit) floating-point elements in a and b for not-greater-than, store the result in the lower element of dst, and

Compare the lower double-precision (64-bit) floating-point elements in a and b for not-less-than-or-equal, store the result in the lower element of ds

Compare the lower single-precision (32-bit) floating-point elements in a and b for not-less-than-or-equal, store the result in the lower element of ds

Compare the lower double-precision (64-bit) floating-point elements in a and b for not-less-than, store the result in the lower element of dst, and co

Compare the lower single-precision (32-bit) floating-point elements in a and b for not-less-than, store the result in the lower element of dst, and co

Compare the lower double-precision (64-bit) floating-point elements in a and b to see if neither is NaN, store the result in the lower element of dst,

Compare the lower single-precision (32-bit) floating-point elements in a and b to see if neither is NaN, store the result in the lower element of dst,