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,

Compare the lower double-precision (64-bit) floating-point elements in a and b to see if either 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 either is NaN, store the result in the lower element of dst,

Compare the lower double-precision (64-bit) floating-point element in a and b for greater-than-or-equal, and return the boolean result (0 or 1). https

Compare the lower single-precision (32-bit) floating-point element in a and b for greater-than-or-equal, and return the boolean result (0 or 1). https

Compare the lower double-precision (64-bit) floating-point element in a and b for greater-than, and return the boolean result (0 or 1). https://www.in

Compare the lower single-precision (32-bit) floating-point element in a and b for greater-than, and return the boolean result (0 or 1). https://www.in

Compare the lower double-precision (64-bit) floating-point element in a and b for less-than-or-equal, and return the boolean result (0 or 1). https://

Compare the lower single-precision (32-bit) floating-point element in a and b for less-than-or-equal, and return the boolean result (0 or 1). https://

Compare the lower double-precision (64-bit) floating-point element in a and b for less-than, and return the boolean result (0 or 1). https://www.intel

Compare the lower single-precision (32-bit) floating-point element in a and b for less-than, and return the boolean result (0 or 1). https://www.intel

Compare the lower double-precision (64-bit) floating-point element in a and b for not-equal, and return the boolean result (0 or 1). https://www.intel

Compare the lower single-precision (32-bit) floating-point element in a and b for not-equal, and return the boolean result (0 or 1). https://www.intel

Starting with the initial value in crc, accumulates a CRC32 value for unsigned 64-bit integer v, and stores the result in dst. https://www.intel.com/c

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

Sign extend packed 16-bit integers in a to packed 64-bit integers, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsi

Sign extend packed 32-bit integers in a to packed 64-bit integers, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsi

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

Sign extend packed 8-bit integers in a to packed 16-bit integers, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsic

Sign extend packed 8-bit integers in the low 8 bytes of a to packed 64-bit integers, and store the results in dst. https://www.intel.com/content/www/u

Zero extend packed unsigned 16-bit integers in a to packed 64-bit integers, and store the results in dst. https://www.intel.com/content/www/us/en/docs

Zero extend packed unsigned 32-bit integers in a to packed 64-bit integers, and store the results in dst. https://www.intel.com/content/www/us/en/docs

Zero extend packed unsigned 8-bit integers in a to packed 16-bit integers, and store the results in dst. https://www.intel.com/content/www/us/en/docs/

Zero extend packed unsigned 8-bit integers in the low 8 bytes of a to packed 64-bit integers, and store the results in dst. https://www.intel.com/cont

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 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 double-precision (64-bit) floating-point elements in a to packed single-precision (32-bit) floating-point elements, and store the resul

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 double-precision (64-bit) floating-point elements, and store the resul

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

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

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

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

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

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

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 the lower single-precision (32-bit) floating-point element in a to a 64-bit integer, and store the result in dst. https://www.intel.com/conten

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

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

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

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

Convert the lower double-precision (64-bit) floating-point element in a to a 32-bit integer with truncation, and store the result in dst. https://www.

Convert the lower double-precision (64-bit) floating-point element in a to a 64-bit integer with truncation, and store the result in dst. https://www.

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

Divide the lower double-precision (64-bit) floating-point element in a by the lower double-precision (64-bit) floating-point element in b, store the r

Divide the lower single-precision (32-bit) floating-point element in a by the lower single-precision (32-bit) floating-point element in b, store the r

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

_mm_empty is a no-op on arm

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

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

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 double-precision (64-bit) floating-point elements in a and b, and pack the results in dst. https://www.intel.com/co

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 single-precision (32-bit) floating-point elements in a and b, and pack the results in dst. https://www.intel.com/co

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 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 double-precision (64-bit) floating-point elements in a and b, and pack the results in dst. https://www.intel.c

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 single-precision (32-bit) floating-point elements in a and b, and pack the results in dst. https://www.intel.c

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

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 double-precision (64-bit) floating-point element from memory into the lower of dst, and zero the upper element. mem_addr does not need to be al

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