Verify all lanes of __m128 are negative infinity */

Verify all lanes of __m128d are negative infinity */

Verify all lanes of __m128 are positive infinity */

Verify all lanes of __m128d are positive infinity */

Find available ARM64 compiler.

Lazy load header content.

Check if cache file is valid (exists and not expired).

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 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

Compute the bitwise NOT of packed double-precision (64-bit) floating-point elements in a and then AND with b, and store the results in dst. https://ww

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

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 __m128 to type __m128d. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero laten

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 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 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 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

Convert packed signed 32-bit integers in b to packed single-precision (32-bit) floating-point elements, store the results in the lower 2 elements of d

Convert packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst. https://www.intel.com/c

Convert the signed 32-bit integer b to a single-precision (32-bit) floating-point element, store the result in the lower element of dst, and copy the

Convert the lower single-precision (32-bit) floating-point element in a to a 32-bit integer, and store the result in dst. https://www.intel.com/conten

Convert packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst. https://www.intel.com/c

Convert packed 16-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst. https://www.intel.com/c

Convert packed signed 32-bit integers in a to packed double-precision (64-bit) floating-point elements, and store the results in dst. https://www.inte

Convert packed 32-bit integers in b to packed single-precision (32-bit) floating-point elements, store the results in the lower 2 elements of dst, and

Convert packed signed 32-bit integers in a to packed single-precision (32-bit) floating-point elements, store the results in the lower 2 elements of d

Convert the lower packed 8-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst. https://www.in

Convert packed single-precision (32-bit) floating-point elements in a to packed 8-bit integers, and store the results in lower 4 elements of dst. Note

Convert packed unsigned 16-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst. https://www.in

Convert the lower packed unsigned 8-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst. https

Copy the lower double-precision (64-bit) floating-point element of a to dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#

Convert the lower double-precision (64-bit) floating-point element in b to a single-precision (32-bit) floating-point element, store the result in the

Copy the lower 64-bit integer in a to dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_cvtsi128_si64

Convert the signed 32-bit integer b to a double-precision (64-bit) floating-point element, store the result in the lower element of dst, and copy the

Copy 32-bit integer a to the lower elements of dst, and zero the upper elements of dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/

Convert the signed 64-bit integer b to a double-precision (64-bit) floating-point element, store the result in the lower element of dst, and copy the

Copy 64-bit integer a to the lower element of dst, and zero the upper element. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.htm

Convert the signed 64-bit integer b to a single-precision (32-bit) floating-point element, store the result in the lower element of dst, and copy the

Copy the lower single-precision (32-bit) floating-point element of a to dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#

Convert the lower single-precision (32-bit) floating-point element in b to a double-precision (64-bit) floating-point element, store the result in the

Convert packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers with truncation, and store the results in dst. https:/

Conditionally multiply the packed double-precision (64-bit) floating-point elements in a and b using the high 4 bits in imm8, sum the four products, a

Horizontally add adjacent pairs of 16-bit integers in a and b, and pack the signed 16-bit results in dst. https://www.intel.com/content/www/us/en/docs

Horizontally add adjacent pairs of 32-bit integers in a and b, and pack the signed 32-bit results in dst. https://www.intel.com/content/www/us/en/docs

Horizontally add adjacent pairs of signed 16-bit integers in a and b using saturation, and pack the signed 16-bit results in dst. https://www.intel.co

Horizontally subtract adjacent pairs of 16-bit integers in a and b, and pack the signed 16-bit results in dst. https://www.intel.com/content/www/us/en

Horizontally subtract adjacent pairs of 32-bit integers in a and b, and pack the signed 32-bit results in dst. https://www.intel.com/content/www/us/en

Horizontally subtract adjacent pairs of signed 16-bit integers in a and b using saturation, and pack the signed 16-bit results in dst. https://www.int

Perform a serializing operation on all load-from-memory instructions that were issued prior to this instruction. Guarantees that every load instructio

Load a double-precision (64-bit) floating-point element from memory into both elements of dst. https://www.intel.com/content/www/us/en/docs/intrinsics

Load a single-precision (32-bit) floating-point element from memory into all elements of dst. https://www.intel.com/content/www/us/en/docs/intrinsics-

Load a single-precision (32-bit) floating-point element from memory into the lower of dst, and zero the upper 3 elements. mem_addr does not need to be

Load a double-precision (64-bit) floating-point element from memory into the upper element of dst, and copy the lower element from a to dst. mem_addr

Load 2 single-precision (32-bit) floating-point elements from memory into the upper 2 elements of dst, and copy the lower 2 elements from a to dst. me

Load a double-precision (64-bit) floating-point element from memory into the lower element of dst, and copy the upper element from a to dst. mem_addr

Load 2 single-precision (32-bit) floating-point elements from memory into the lower 2 elements of dst, and copy the upper 2 elements from a to dst. me

Load 2 double-precision (64-bit) floating-point elements from memory into dst in reverse order. mem_addr must be aligned on a 16-byte boundary or a ge

Load 4 single-precision (32-bit) floating-point elements from memory into dst in reverse order. mem_addr must be aligned on a 16-byte boundary or a ge

Load unaligned 16-bit integer from memory into the first element of dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text

Load unaligned 64-bit integer from memory into the first element of dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text

Vertically multiply each unsigned 8-bit integer from a with the corresponding signed 8-bit integer from b, producing intermediate signed 16-bit intege

Conditionally store 8-bit integer elements from a into memory using mask (elements are not stored when the highest bit is not set in the corresponding

Compare packed signed 16-bit integers in a and b, and store packed maximum values in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guid

Compare packed unsigned 8-bit integers in a and b, and store packed maximum values in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-gui

Perform a serializing operation on all load-from-memory and store-to-memory instructions that were issued prior to this instruction. Guarantees that e

Compare packed signed 16-bit integers in a and b, and store packed minimum values in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guid

Compare packed unsigned 8-bit integers in a and b, and store packed minimum values in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-gui

Sets up a linear address range to be monitored by hardware and activates the monitor. The address range should be a write-back memory caching type. A

Copy the lower 64-bit integer in a to the lower element of dst, and zero the upper element. https://www.intel.com/content/www/us/en/docs/intrinsics-gu

Move the lower 2 single-precision (32-bit) floating-point elements from b to the upper 2 elements of dst, and copy the lower 2 elements from a to the

Copy the lower 64-bit integer in a to dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_movepi64_pi64

Copy the 64-bit integer a to the lower element of dst, and zero the upper element. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index

Compute the sum of absolute differences (SADs) of quadruplets of unsigned 8-bit integers in a compared to those in b, and store the 16-bit results in

Multiply the low unsigned 32-bit integers from a and b, and store the unsigned 64-bit result in dst. https://www.intel.com/content/www/us/en/docs/intr