# X86.Avx

> AVX intrinsics

## Definition

* **Type:** Class
* **Namespace:** [Unity.Burst.Intrinsics](/engine/6000.7/script-reference/unity/burst/intrinsics.md)
* **Assembly:** UnityEngine.BurstModule

```csharp
public static class X86.Avx
```

## Static Properties

| Property                                                                                           | Description                                                        |
| -------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
| [IsAvxSupported](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/isavxsupported.md) | Evaluates to true at compile time if AVX intrinsics are supported. |

## Static Methods

| Method                                                                                                                   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| ------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [broadcast\_ss](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/broadcast-ss.md)                          | Broadcast a single-precision (32-bit) floating-point element from memory to all elements of dst.                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [cmp\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/cmp-pd.md)                                      | Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                       |
| [cmp\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/cmp-ps.md)                                      | Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                       |
| [cmp\_sd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/cmp-sd.md)                                      | Compare the lower double-precision (64-bit) floating-point element in a and b based on the comparison operand specified by imm8, store the result in the lower element of dst, and copy the upper element from a to the upper element of dst.                                                                                                                                                                                                                                                                                                      |
| [cmp\_ss](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/cmp-ss.md)                                      | Compare the lower single-precision (32-bit) floating-point element in a and b based on the comparison operand specified by imm8, store the result in the lower element of dst, and copy the upper 3 packed elements from a to the upper elements of dst.                                                                                                                                                                                                                                                                                           |
| [maskload\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/maskload-pd.md)                            | Load packed double-precision (64-bit) floating-point elements from memory into dst using mask (elements are zeroed out when the high bit of the corresponding element is not set).                                                                                                                                                                                                                                                                                                                                                                 |
| [maskload\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/maskload-ps.md)                            | Load packed single-precision (32-bit) floating-point elements from memory into dst using mask (elements are zeroed out when the high bit of the corresponding element is not set).                                                                                                                                                                                                                                                                                                                                                                 |
| [maskstore\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/maskstore-pd.md)                          | Store packed double-precision (64-bit) floating-point elements from a into memory using mask.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [maskstore\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/maskstore-ps.md)                          | Store packed single-precision (32-bit) floating-point elements from a into memory using mask.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_add\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-add-pd.md)                         | Add packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [mm256\_add\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-add-ps.md)                         | Add packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [mm256\_addsub\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-addsub-pd.md)                   | 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 dst.                                                                                                                                                                                                                                                                                                                                                                                           |
| [mm256\_addsub\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-addsub-ps.md)                   | 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 dst.                                                                                                                                                                                                                                                                                                                                                                                           |
| [mm256\_and\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-and-pd.md)                         | Compute the bitwise AND of packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_and\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-and-ps.md)                         | Compute the bitwise AND of packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_andnot\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-andnot-pd.md)                   | 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.                                                                                                                                                                                                                                                                                                                                                                                                        |
| [mm256\_andnot\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-andnot-ps.md)                   | Compute the bitwise NOT of packed single-precision (32-bit) floating-point elements in a and then AND with b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                        |
| [mm256\_blend\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-blend-pd.md)                     | Blend packed double-precision (64-bit) floating-point elements from a and b using control mask imm8, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_blend\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-blend-ps.md)                     | Blend packed single-precision (32-bit) floating-point elements from a and b using control mask imm8, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_blendv\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-blendv-pd.md)                   | Blend packed double-precision (64-bit) floating-point elements from a and b using mask, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [mm256\_blendv\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-blendv-ps.md)                   | Blend packed single-precision (32-bit) floating-point elements from a and b using mask, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [mm256\_broadcast\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-broadcast-pd.md)             | Broadcast 128 bits from memory (composed of 2 packed double-precision (64-bit) floating-point elements) to all elements of dst.                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [mm256\_broadcast\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-broadcast-ps.md)             | Broadcast 128 bits from memory (composed of 4 packed single-precision (32-bit) floating-point elements) to all elements of dst.                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [mm256\_broadcast\_sd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-broadcast-sd.md)             | Broadcast a double-precision (64-bit) floating-point element from memory to all elements of dst.                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [mm256\_broadcast\_ss](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-broadcast-ss.md)             | Broadcast a single-precision (32-bit) floating-point element from memory to all elements of dst.                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [mm256\_castpd128\_pd256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-castpd128-pd256.md)       | For compatibility with C++ code only. This is a no-op in Burst.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [mm256\_castpd256\_pd128](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-castpd256-pd128.md)       | For compatibility with C++ code only. This is a no-op in Burst.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [mm256\_castpd\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-castpd-ps.md)                   | For compatibility with C++ code only. This is a no-op in Burst.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [mm256\_castpd\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-castpd-si256.md)             | For compatibility with C++ code only. This is a no-op in Burst.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [mm256\_castps128\_ps256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-castps128-ps256.md)       | For compatibility with C++ code only. This is a no-op in Burst.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [mm256\_castps256\_ps128](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-castps256-ps128.md)       | For compatibility with C++ code only. This is a no-op in Burst.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [mm256\_castps\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-castps-pd.md)                   | For compatibility with C++ code only. This is a no-op in Burst.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [mm256\_castps\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-castps-si256.md)             | For compatibility with C++ code only. This is a no-op in Burst.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [mm256\_castsi128\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-castsi128-si256.md)       | For compatibility with C++ code only. This is a no-op in Burst.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [mm256\_castsi256\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-castsi256-pd.md)             | For compatibility with C++ code only. This is a no-op in Burst.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [mm256\_castsi256\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-castsi256-ps.md)             | For compatibility with C++ code only. This is a no-op in Burst.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [mm256\_castsi256\_si128](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-castsi256-si128.md)       | For compatibility with C++ code only. This is a no-op in Burst.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [mm256\_ceil\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-ceil-pd.md)                       | Round the packed double-precision (64-bit) floating-point elements in a up to an integer value, and store the results as packed double-precision floating-point elements in dst.                                                                                                                                                                                                                                                                                                                                                                   |
| [mm256\_ceil\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-ceil-ps.md)                       | Round the packed single-precision (32-bit) floating-point elements in a up to an integer value, and store the results as packed single-precision floating-point elements in dst.                                                                                                                                                                                                                                                                                                                                                                   |
| [mm256\_cmp\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-cmp-pd.md)                         | Compare packed double-precision (64-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                       |
| [mm256\_cmp\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-cmp-ps.md)                         | Compare packed single-precision (32-bit) floating-point elements in a and b based on the comparison operand specified by imm8, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                       |
| [mm256\_cvtepi32\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-cvtepi32-pd.md)               | Convert packed 32-bit integers in a to packed double-precision (64-bit) floating-point elements, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [mm256\_cvtepi32\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-cvtepi32-ps.md)               | Convert packed 32-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [mm256\_cvtpd\_epi32](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-cvtpd-epi32.md)               | Convert packed double-precision(64-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_cvtpd\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-cvtpd-ps.md)                     | Convert packed double-precision (64-bit) floating-point elements in a to packed single-precision (32-bit) floating-point elements, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                   |
| [mm256\_cvtps\_epi32](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-cvtps-epi32.md)               | Convert packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [mm256\_cvtps\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-cvtps-pd.md)                     | Convert packed single-precision (32-bit) floating-point elements in a to packed double-precision (64-bit) floating-point elements, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                   |
| [mm256\_cvtss\_f32](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-cvtss-f32.md)                   | Copy the lower single-precision (32-bit) floating-point element of a to dst.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [mm256\_cvttpd\_epi32](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-cvttpd-epi32.md)             | Convert packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers with truncation, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                     |
| [mm256\_cvttps\_epi32](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-cvttps-epi32.md)             | Convert packed single-precision (32-bit) floating-point elements in a to packed 32-bit integers with truncation, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                     |
| [mm256\_div\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-div-pd.md)                         | Divide packed double-precision (64-bit) floating-point elements in a by packed elements in b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [mm256\_div\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-div-ps.md)                         | Divide packed single-precision (32-bit) floating-point elements in a by packed elements in b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [mm256\_dp\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-dp-ps.md)                           | Conditionally multiply the packed single-precision (32-bit) floating-point elements in a and b using the high 4 bits in imm8, sum the four products, and conditionally store the sum in dst using the low 4 bits of imm8.                                                                                                                                                                                                                                                                                                                          |
| [mm256\_extract\_epi32](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-extract-epi32.md)           | Extract a 32-bit integer from a, selected with index (which must be a constant), and store the result in dst.                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_extract\_epi64](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-extract-epi64.md)           | Extract a 64-bit integer from a, selected with index (which must be a constant), and store the result in dst.                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_extractf128\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-extractf128-pd.md)         | Extract 128 bits (composed of 2 packed double-precision (64-bit) floating-point elements) from a, selected with imm8, and store the result in dst.                                                                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_extractf128\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-extractf128-ps.md)         | Extract 128 bits (composed of 4 packed single-precision (32-bit) floating-point elements) from a, selected with imm8, and store the result in dst.                                                                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_extractf128\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-extractf128-si256.md)   | Extract 128 bits (composed of integer data) from a, selected with imm8, and store the result in dst.                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [mm256\_floor\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-floor-pd.md)                     | Round the packed double-precision (64-bit) floating-point elements in a down to an integer value, and store the results as packed double-precision floating-point elements in dst.                                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_floor\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-floor-ps.md)                     | Round the packed single-precision (32-bit) floating-point elements in a down to an integer value, and store the results as packed single-precision floating-point elements in dst.                                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_hadd\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-hadd-pd.md)                       | Horizontally add adjacent pairs of double-precision (64-bit) floating-point elements in a and b, and pack the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_hadd\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-hadd-ps.md)                       | Horizontally add adjacent pairs of single-precision (32-bit) floating-point elements in a and b, and pack the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_hsub\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-hsub-pd.md)                       | Horizontally subtract adjacent pairs of double-precision (64-bit) floating-point elements in a and b, and pack the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_hsub\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-hsub-ps.md)                       | Horizontally add adjacent pairs of single-precision (32-bit) floating-point elements in a and b, and pack the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_insert\_epi16](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-insert-epi16.md)             | Copy a to dst, and insert the 16-bit integer i into dst at the location specified by index (which must be a constant).                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [mm256\_insert\_epi32](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-insert-epi32.md)             | Copy a to dst, and insert the 32-bit integer i into dst at the location specified by index (which must be a constant).                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [mm256\_insert\_epi64](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-insert-epi64.md)             | Copy a to dst, and insert the 64-bit integer i into dst at the location specified by index (which must be a constant).                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [mm256\_insert\_epi8](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-insert-epi8.md)               | Copy a to dst, and insert the 8-bit integer i into dst at the location specified by index (which must be a constant).                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [mm256\_insertf128\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-insertf128-pd.md)           | Copy a to dst, then insert 128 bits (composed of 2 packed double-precision (64-bit) floating-point elements) from b into dst at the location specified by imm8.                                                                                                                                                                                                                                                                                                                                                                                    |
| [mm256\_insertf128\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-insertf128-ps.md)           | Copy a to dst, then insert 128 bits (composed of 4 packed single-precision (32-bit) floating-point elements) from b into dst at the location specified by imm8.                                                                                                                                                                                                                                                                                                                                                                                    |
| [mm256\_insertf128\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-insertf128-si256.md)     | Copy a to dst, then insert 128 bits of integer data from b into dst at the location specified by imm8.                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [mm256\_lddqu\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-lddqu-si256.md)               | Load 256-bits of integer data from unaligned memory into dst. This intrinsic may perform better than mm256\_loadu\_si256 when the data crosses a cache line boundary.                                                                                                                                                                                                                                                                                                                                                                              |
| [mm256\_load\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-load-pd.md)                       | Load 256-bits (composed of 8 packed single-precision (32-bit) floating-point elements) from memory                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_load\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-load-ps.md)                       | Load 256-bits (composed of 8 packed single-precision (32-bit) floating-point elements) from memory                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_load\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-load-si256.md)                 | Load 256-bits (composed of 8 packed 32-bit integers elements) from memory                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| [mm256\_loadu2\_m128](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-loadu2-m128.md)               | Load two 128-bit values (composed of 4 packed single-precision (32-bit) floating-point elements) from memory, and combine them into a 256-bit value in dst. hiaddr and loaddr do not need to be aligned on any particular boundary.                                                                                                                                                                                                                                                                                                                |
| [mm256\_loadu2\_m128d](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-loadu2-m128d.md)             | Load two 128-bit values (composed of 2 packed double-precision (64-bit) floating-point elements) from memory, and combine them into a 256-bit value in dst. hiaddr and loaddr do not need to be aligned on any particular boundary.                                                                                                                                                                                                                                                                                                                |
| [mm256\_loadu2\_m128i](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-loadu2-m128i.md)             | Load two 128-bit values (composed of integer data) from memory, and combine them into a 256-bit value in dst. hiaddr and loaddr do not need to be aligned on any particular boundary.                                                                                                                                                                                                                                                                                                                                                              |
| [mm256\_loadu\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-loadu-pd.md)                     | Load 256-bits (composed of 4 packed double-precision (64-bit) floating-point elements) from memory                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_loadu\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-loadu-ps.md)                     | Load 256-bits (composed of 8 packed single-precision (32-bit) floating-point elements) from memory                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_loadu\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-loadu-si256.md)               | Load 256-bits (composed of 8 packed 32-bit integers elements) from memory                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| [mm256\_maskload\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-maskload-pd.md)               | Load packed double-precision (64-bit) floating-point elements from memory into dst using mask (elements are zeroed out when the high bit of the corresponding element is not set).                                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_maskload\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-maskload-ps.md)               | Load packed single-precision (32-bit) floating-point elements from memory into dst using mask (elements are zeroed out when the high bit of the corresponding element is not set).                                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_maskstore\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-maskstore-pd.md)             | Store packed double-precision (64-bit) floating-point elements from a into memory using mask.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_maskstore\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-maskstore-ps.md)             | Store packed single-precision (32-bit) floating-point elements from a into memory using mask.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_max\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-max-pd.md)                         | Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed maximum values in dst.                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [mm256\_max\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-max-ps.md)                         | Compare packed single-precision (32-bit) floating-point elements in a and b, and store packed maximum values in dst.                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [mm256\_min\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-min-pd.md)                         | Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed minimum values in dst.                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [mm256\_min\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-min-ps.md)                         | Compare packed single-precision (32-bit) floating-point elements in a and b, and store packed minimum values in dst.                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [mm256\_movedup\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-movedup-pd.md)                 | Duplicate even-indexed double-precision (64-bit) floating-point elements from a, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [mm256\_movehdup\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-movehdup-ps.md)               | Duplicate odd-indexed single-precision (32-bit) floating-point elements from a, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_moveldup\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-moveldup-ps.md)               | Duplicate even-indexed single-precision (32-bit) floating-point elements from a, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [mm256\_movemask\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-movemask-pd.md)               | Set each bit of mask dst based on the most significant bit of the corresponding packed double-precision (64-bit) floating-point element in a.                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_movemask\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-movemask-ps.md)               | Set each bit of mask dst based on the most significant bit of the corresponding packed single-precision (32-bit) floating-point element in a.                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_mul\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-mul-pd.md)                         | Multiply packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [mm256\_mul\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-mul-ps.md)                         | Multiply packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [mm256\_or\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-or-pd.md)                           | Compute the bitwise OR of packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [mm256\_or\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-or-ps.md)                           | Compute the bitwise OR of packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [mm256\_permute2f128\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-permute2f128-pd.md)       | Shuffle 128-bits (composed of 2 packed double-precision (64-bit) floating-point elements) selected by imm8 from a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                             |
| [mm256\_permute2f128\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-permute2f128-ps.md)       | Shuffle 128-bits (composed of 4 packed single-precision (32-bit) floating-point elements) selected by imm8 from a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                             |
| [mm256\_permute2f128\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-permute2f128-si256.md) | Shuffle 128-bits (composed of integer data) selected by imm8 from a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| [mm256\_permute\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-permute-pd.md)                 | Shuffle double-precision (64-bit) floating-point elements in a within 128-bit lanes using the control in imm8, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                       |
| [mm256\_permute\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-permute-ps.md)                 | Shuffle single-precision (32-bit) floating-point elements in a within 128-bit lanes using the control in imm8, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                       |
| [mm256\_permutevar\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-permutevar-pd.md)           | Shuffle double-precision (64-bit) floating-point elements in a within 128-bit lanes using the control in b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                          |
| [mm256\_permutevar\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-permutevar-ps.md)           | Shuffle single-precision (32-bit) floating-point elements in a within 128-bit lanes using the control in b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                          |
| [mm256\_rcp\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-rcp-ps.md)                         | Compute the approximate reciprocal of packed single-precision (32-bit) floating-point elements in a, and store the results in dst. The maximum relative error for this approximation is less than 1.5\*2^-12.                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_round\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-round-pd.md)                     | Round the packed double-precision (64-bit) floating-point elements in a using the rounding parameter, and store the results as packed double-precision floating-point elements in dst.                                                                                                                                                                                                                                                                                                                                                             |
| [mm256\_round\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-round-ps.md)                     | Round the packed single-precision (32-bit) floating-point elements in a using the rounding parameter, and store the results as packed single-precision floating-point elements in dst.                                                                                                                                                                                                                                                                                                                                                             |
| [mm256\_rsqrt\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-rsqrt-ps.md)                     | Compute the approximate reciprocal square root of packed single-precision (32-bit) floating-point elements in a, and store the results in dst. The maximum relative error for this approximation is less than 1.5\*2^-12.                                                                                                                                                                                                                                                                                                                          |
| [mm256\_set1\_epi16](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-set1-epi16.md)                 | Broadcast 16-bit integer a to all all elements of dst. This intrinsic may generate the vpbroadcastw instruction.                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [mm256\_set1\_epi32](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-set1-epi32.md)                 | Broadcast 32-bit integer a to all elements of dst. This intrinsic may generate the vpbroadcastd instruction.                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [mm256\_set1\_epi64x](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-set1-epi64x.md)               | Broadcast 64-bit integer a to all elements of dst. This intrinsic may generate the vpbroadcastq instruction.                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [mm256\_set1\_epi8](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-set1-epi8.md)                   | Broadcast 8-bit integer a to all elements of dst. This intrinsic may generate the vpbroadcastb instruction.                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [mm256\_set1\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-set1-pd.md)                       | Broadcast double-precision (64-bit) floating-point value a to all elements of dst.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_set1\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-set1-ps.md)                       | Broadcast single-precision (32-bit) floating-point value a to all elements of dst.                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_set\_epi16](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-set-epi16.md)                   | Set packed short elements in dst with the supplied values.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [mm256\_set\_epi32](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-set-epi32.md)                   | Set packed int elements in dst with the supplied values.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| [mm256\_set\_epi64x](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-set-epi64x.md)                 | Set packed 64-bit integers in dst with the supplied values.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [mm256\_set\_epi8](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-set-epi8.md)                     | Set packed byte elements in dst with the supplied values.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| [mm256\_set\_m128](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-set-m128.md)                     | Set packed \_\_m256 vector dst with the supplied values.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| [mm256\_set\_m128d](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-set-m128d.md)                   | Set packed v256 vector with the supplied values.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [mm256\_set\_m128i](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-set-m128i.md)                   | Set packed v256 vector with the supplied values.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [mm256\_set\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-set-pd.md)                         | Set packed double-precision (64-bit) floating-point elements in dst with the supplied values.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_set\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-set-ps.md)                         | Set packed single-precision (32-bit) floating-point elements in dst with the supplied values.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_setr\_epi16](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-setr-epi16.md)                 | Set packed short elements in dst with the supplied values in reverse order.                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [mm256\_setr\_epi32](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-setr-epi32.md)                 | Set packed int elements in dst with the supplied values in reverse order.                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| [mm256\_setr\_epi64x](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-setr-epi64x.md)               | Set packed 64-bit integers in dst with the supplied values in reverse order.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [mm256\_setr\_epi8](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-setr-epi8.md)                   | Set packed byte elements in dst with the supplied values in reverse order.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [mm256\_setr\_m128](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-setr-m128.md)                   | Set packed v256 vector with the supplied values in reverse order.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [mm256\_setr\_m128d](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-setr-m128d.md)                 | Set packed v256 vector with the supplied values in reverse order.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [mm256\_setr\_m128i](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-setr-m128i.md)                 | Set packed v256 vector with the supplied values in reverse order.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [mm256\_setr\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-setr-pd.md)                       | Set packed double-precision (64-bit) floating-point elements in dst with the supplied values in reverse order.                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [mm256\_setr\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-setr-ps.md)                       | Set packed single-precision (32-bit) floating-point elements in dst with the supplied values in reverse order.                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [mm256\_setzero\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-setzero-pd.md)                 | Return Vector with all elements set to zero.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [mm256\_setzero\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-setzero-ps.md)                 | Return Vector with all elements set to zero.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [mm256\_setzero\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-setzero-si256.md)           | Return Vector with all elements set to zero.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [mm256\_shuffle\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-shuffle-pd.md)                 | Shuffle double-precision (64-bit) floating-point elements within 128-bit lanes using the control in imm8, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                            |
| [mm256\_shuffle\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-shuffle-ps.md)                 | Shuffle single-precision (32-bit) floating-point elements in a within 128-bit lanes using the control in imm8, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                       |
| [mm256\_sqrt\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-sqrt-pd.md)                       | Compute the square root of packed double-precision (64-bit) floating-point elements in a, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [mm256\_sqrt\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-sqrt-ps.md)                       | Compute the square root of packed single-precision (32-bit) floating-point elements in a, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [mm256\_store\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-store-pd.md)                     | Store 256-bits (composed of 4 packed double-precision (64-bit) floating-point elements) from a into memory                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [mm256\_store\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-store-ps.md)                     | Store 256-bits (composed of 8 packed single-precision (32-bit) floating-point elements) from a into memory                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [mm256\_store\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-store-si256.md)               | Store 256-bits (composed of 8 packed 32-bit integer elements) from a into memory                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [mm256\_storeu2\_m128](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-storeu2-m128.md)             | Store the high and low 128-bit halves (each composed of 4 packed single-precision (32-bit) floating-point elements) from a into memory two different 128-bit locations. hiaddr and loaddr do not need to be aligned on any particular boundary.                                                                                                                                                                                                                                                                                                    |
| [mm256\_storeu2\_m128d](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-storeu2-m128d.md)           | Store the high and low 128-bit halves (each composed of 2 packed double-precision (64-bit) floating-point elements) from a into memory two different 128-bit locations. hiaddr and loaddr do not need to be aligned on any particular boundary.                                                                                                                                                                                                                                                                                                    |
| [mm256\_storeu2\_m128i](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-storeu2-m128i.md)           | Store the high and low 128-bit halves (each composed of integer data) from a into memory two different 128-bit locations. hiaddr and loaddr do not need to be aligned on any particular boundary.                                                                                                                                                                                                                                                                                                                                                  |
| [mm256\_storeu\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-storeu-pd.md)                   | Store 256-bits (composed of 4 packed double-precision (64-bit) floating-point elements) from a into memory                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [mm256\_storeu\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-storeu-ps.md)                   | Store 256-bits (composed of 8 packed single-precision (32-bit) floating-point elements) from a into memory                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [mm256\_storeu\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-storeu-si256.md)             | Store 256-bits (composed of 8 packed 32-bit integer elements) from a into memory                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [mm256\_stream\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-stream-pd.md)                   | Store 256-bits (composed of 4 packed double-precision (64-bit) floating-point elements) from a into memory using a non-temporal memory hint. mem\_addr must be aligned on a 32-byte boundary or a general-protection exception may be generated.                                                                                                                                                                                                                                                                                                   |
| [mm256\_stream\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-stream-ps.md)                   | Store 256-bits (composed of 8 packed single-precision (32-bit) floating-point elements) from a into memory using a non-temporal memory hint. mem\_addr must be aligned on a 32-byte boundary or a general-protection exception may be generated.                                                                                                                                                                                                                                                                                                   |
| [mm256\_stream\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-stream-si256.md)             | Store 256-bits of integer data from a into memory using a non-temporal memory hint. mem\_addr must be aligned on a 32-byte boundary or a general-protection exception may be generated.                                                                                                                                                                                                                                                                                                                                                            |
| [mm256\_sub\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-sub-pd.md)                         | Subtract packed double-precision (64-bit) floating-point elements in b from packed double-precision (64-bit) floating-point elements in a, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                           |
| [mm256\_sub\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-sub-ps.md)                         | Subtract packed single-precision (32-bit) floating-point elements in b from packed single-precision (32-bit) floating-point elements in a, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                           |
| [mm256\_testc\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-testc-pd.md)                     | Compute the bitwise AND of 256 bits (representing double-precision (64-bit) floating-point elements) in a and b, producing an intermediate 256-bit value, and set ZF to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set ZF to 0. Compute the bitwise NOT of a and then AND with b, producing an intermediate value, and set CF to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set CF to 0. Return the CF value.                                                |
| [mm256\_testc\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-testc-ps.md)                     | Compute the bitwise AND of 256 bits (representing single-precision (32-bit) floating-point elements) in a and b, producing an intermediate 256-bit value, and set ZF to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set ZF to 0. Compute the bitwise NOT of a and then AND with b, producing an intermediate value, and set CF to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set CF to 0. Return the CF value.                                                |
| [mm256\_testc\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-testc-si256.md)               | Compute the bitwise AND of 256 bits (representing integer data) in a and b, and set ZF to 1 if the result is zero, otherwise set ZF to 0. Compute the bitwise NOT of a and then AND with b, and set CF to 1 if the result is zero, otherwise set CF to 0. Return the CF value.                                                                                                                                                                                                                                                                     |
| [mm256\_testnzc\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-testnzc-pd.md)                 | Compute the bitwise AND of 256 bits (representing double-precision (64-bit) floating-point elements) in a and b, producing an intermediate 256-bit value, and set ZF to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set ZF to 0. Compute the bitwise NOT of a and then AND with b, producing an intermediate value, and set CF to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set CF to 0. Return 1 if both the ZF and CF values are zero, otherwise return 0. |
| [mm256\_testnzc\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-testnzc-ps.md)                 | Compute the bitwise AND of 256 bits (representing single-precision (32-bit) floating-point elements) in a and b, producing an intermediate 256-bit value, and set ZF to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set ZF to 0. Compute the bitwise NOT of a and then AND with b, producing an intermediate value, and set CF to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set CF to 0. Return 1 if both the ZF and CF values are zero, otherwise return 0. |
| [mm256\_testnzc\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-testnzc-si256.md)           | Compute the bitwise AND of 256 bits (representing integer data) in a and b, and set ZF to 1 if the result is zero, otherwise set ZF to 0. Compute the bitwise NOT of a and then AND with b, and set CF to 1 if the result is zero, otherwise set CF to 0. Return 1 if both the ZF and CF values are zero, otherwise return 0.                                                                                                                                                                                                                      |
| [mm256\_testz\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-testz-pd.md)                     | Compute the bitwise AND of 256 bits (representing double-precision (64-bit) floating-point elements) in a and b, producing an intermediate 256-bit value, and set ZF to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set ZF to 0. Compute the bitwise NOT of a and then AND with b, producing an intermediate value, and set CF to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set CF to 0. Return the ZF value.                                                |
| [mm256\_testz\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-testz-ps.md)                     | Compute the bitwise AND of 256 bits (representing single-precision (32-bit) floating-point elements) in a and b, producing an intermediate 256-bit value, and set ZF to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set ZF to 0. Compute the bitwise NOT of a and then AND with b, producing an intermediate value, and set CF to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set CF to 0. Return the ZF value.                                                |
| [mm256\_testz\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-testz-si256.md)               | Compute the bitwise AND of 256 bits (representing integer data) in a and b, and set ZF to 1 if the result is zero, otherwise set ZF to 0. Compute the bitwise NOT of a and then AND with b, and set CF to 1 if the result is zero, otherwise set CF to 0. Return the ZF value.                                                                                                                                                                                                                                                                     |
| [mm256\_undefined\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-undefined-pd.md)             | Return a 256-bit vector with undefined contents.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [mm256\_undefined\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-undefined-ps.md)             | Return a 256-bit vector with undefined contents.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [mm256\_undefined\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-undefined-si256.md)       | Return a 256-bit vector with undefined contents.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [mm256\_unpackhi\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-unpackhi-pd.md)               | Unpack and interleave double-precision (64-bit) floating-point elements from the high half of each 128-bit lane in a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                          |
| [mm256\_unpackhi\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-unpackhi-ps.md)               | Unpack and interleave single-precision(32-bit) floating-point elements from the high half of each 128-bit lane in a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                           |
| [mm256\_unpacklo\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-unpacklo-pd.md)               | Unpack and interleave double-precision (64-bit) floating-point elements from the low half of each 128-bit lane in a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                           |
| [mm256\_unpacklo\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-unpacklo-ps.md)               | Unpack and interleave single-precision (32-bit) floating-point elements from the low half of each 128-bit lane in a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                           |
| [mm256\_xor\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-xor-pd.md)                         | Compute the bitwise XOR of packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_xor\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-xor-ps.md)                         | Compute the bitwise XOR of packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [mm256\_zeroall](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-zeroall.md)                        | Zeros the contents of all YMM registers                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [mm256\_zeroupper](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-zeroupper.md)                    | Zero the upper 128 bits of all YMM registers; the lower 128-bits of the registers are unmodified.                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [mm256\_zextpd128\_pd256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-zextpd128-pd256.md)       | Casts vector of type v128 to type v256; the upper 128 bits of the result are zeroed. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency.                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_zextps128\_ps256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-zextps128-ps256.md)       | Casts vector of type v128 to type v256; the upper 128 bits of the result are zeroed. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency.                                                                                                                                                                                                                                                                                                                                                 |
| [mm256\_zextsi128\_si256](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/mm256-zextsi128-si256.md)       | Casts vector of type v128 to type v256; the upper 128 bits of the result are zeroed. This intrinsic is only used for compilation and does not generate any instructions, thus it has zero latency.                                                                                                                                                                                                                                                                                                                                                 |
| [permute\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/permute-pd.md)                              | Shuffle double-precision (64-bit) floating-point elements in a using the control in imm8, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [permute\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/permute-ps.md)                              | Shuffle single-precision (32-bit) floating-point elements in a using the control in imm8, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [permutevar\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/permutevar-pd.md)                        | Shuffle double-precision (64-bit) floating-point elements in a using the control in b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [permutevar\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/permutevar-ps.md)                        | Shuffle single-precision (32-bit) floating-point elements in a using the control in b, and store the results in dst.                                                                                                                                                                                                                                                                                                                                                                                                                               |
| [testc\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/testc-pd.md)                                  | Compute the bitwise AND of 128 bits (representing double-precision (64-bit) floating-point elements) in a and b, producing an intermediate 128-bit value, and set ZF to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set ZF to 0. Compute the bitwise NOT of a and then AND with b, producing an intermediate value, and set CF to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set CF to 0. Return the CF value.                                                |
| [testc\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/testc-ps.md)                                  | Compute the bitwise AND of 128 bits (representing single-precision (32-bit) floating-point elements) in a and b, producing an intermediate 128-bit value, and set ZF to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set ZF to 0. Compute the bitwise NOT of a and then AND with b, producing an intermediate value, and set CF to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set CF to 0. Return the CF value.                                                |
| [testnzc\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/testnzc-pd.md)                              | Compute the bitwise AND of 128 bits (representing double-precision (64-bit) floating-point elements) in a and b, producing an intermediate 128-bit value, and set ZF to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set ZF to 0. Compute the bitwise NOT of a and then AND with b, producing an intermediate value, and set CF to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set CF to 0. Return 1 if both the ZF and CF values are zero, otherwise return 0. |
| [testnzc\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/testnzc-ps.md)                              | Compute the bitwise AND of 128 bits (representing single-precision (32-bit) floating-point elements) in a and b, producing an intermediate 128-bit value, and set ZF to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set ZF to 0. Compute the bitwise NOT of a and then AND with b, producing an intermediate value, and set CF to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set CF to 0. Return 1 if both the ZF and CF values are zero, otherwise return 0. |
| [testz\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/testz-pd.md)                                  | Compute the bitwise AND of 128 bits (representing double-precision (64-bit) floating-point elements) in a and b, producing an intermediate 128-bit value, and set ZF to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set ZF to 0. Compute the bitwise NOT of a and then AND with b, producing an intermediate value, and set CF to 1 if the sign bit of each 64-bit element in the intermediate value is zero, otherwise set CF to 0. Return the ZF value.                                                |
| [testz\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/testz-ps.md)                                  | Compute the bitwise AND of 128 bits (representing single-precision (32-bit) floating-point elements) in a and b, producing an intermediate 128-bit value, and set ZF to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set ZF to 0. Compute the bitwise NOT of a and then AND with b, producing an intermediate value, and set CF to 1 if the sign bit of each 32-bit element in the intermediate value is zero, otherwise set CF to 0. Return the ZF value.                                                |
| [undefined\_pd](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/undefined-pd.md)                          | Return a 128-bit vector with undefined contents.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [undefined\_ps](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/undefined-ps.md)                          | Return a 128-bit vector with undefined contents.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [undefined\_si128](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avx/undefined-si128.md)                    | Return a 128-bit vector with undefined contents.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |

## Enums

| Enum                                                                                | Description                                                          |
| ----------------------------------------------------------------------------------- | -------------------------------------------------------------------- |
| [X86.Avx.CMP](/engine/6000.7/script-reference/unity/burst/intrinsics/x86/avxcmp.md) | Compare predicates for scalar and packed compare intrinsic functions |
