From 5e3a64d643b41ac2a563ebdb05e0ff9bd121c770 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Wed, 18 Aug 2021 13:22:30 -0700
Subject: [PATCH 01/94] Update license file to conform to standard. (#195)

---
 LICENSE.md | 32 +++-----------------------------
 1 file changed, 3 insertions(+), 29 deletions(-)

diff --git a/LICENSE.md b/LICENSE.md
index 311c9904..c86bf6a7 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,30 +1,4 @@
-Unity Companion License (“License”)
-Software Copyright © 2019 Unity Technologies ApS 
- 
-Unity Technologies ApS (“Unity”) grants to you a worldwide, non-exclusive, no-charge, and royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute the software that is made available under this License (“Software”), subject to the following terms and conditions: 
- 
-1. Unity Companion Use Only. Exercise of the license granted herein is limited to exercise for the creation, use, and/or distribution of applications, software, or other content pursuant to a valid Unity content authoring and rendering engine software license (“Engine License”). That means while use of the Software is not limited to use in the software licensed under the Engine License, the Software may not be used for any purpose other than the creation, use, and/or distribution of Engine License-dependent applications, software, or other content. No other exercise of the license granted herein is permitted, and in no event may the Software be used for competitive analysis or to develop a competing product or service.
- 
-2. No Modification of Engine License. Neither this License nor any exercise of the license granted herein modifies the Engine License in any way.
- 
-3. Ownership & Grant Back to You. 
+Unity.Mathematics © 2019 Unity Technologies
 
-3.1 You own your content. In this License, “derivative works” means derivatives of the Software itself--works derived only from the Software by you under this License (for example, modifying the code of the Software itself to improve its efficacy); “derivative works” of the Software do not include, for example, games, apps, or content that you create using the Software. You keep all right, title, and interest to your own content.
-
-3.2 Unity owns its content. While you keep all right, title, and interest to your own content per the above, as between Unity and you, Unity will own all right, title, and interest to all intellectual property rights (including patent, trademark, and copyright) in the Software and derivative works of the Software, and you hereby assign and agree to assign all such rights in those derivative works to Unity. 
-
-3.3 You have a license to those derivative works. Subject to this License, Unity grants to you the same worldwide, non-exclusive, no-charge, and royalty-free copyright license to derivative works of the Software you create as is granted to you for the Software under this License.
- 
-4. Trademarks. You are not granted any right or license under this License to use any trademarks, service marks, trade names, products names, or branding of Unity or its affiliates (“Trademarks”). Descriptive uses of Trademarks are permitted; see, for example, Unity’s Branding Usage Guidelines at https://unity3d.com/public-relations/brand.
- 
-5. Notices & Third-Party Rights. This License, including the copyright notice associated with the Software, must be provided in all substantial portions of the Software and derivative works thereof (or, if that is impracticable, in any other location where such notices are customarily placed). Further, if the Software is accompanied by a Unity “third-party notices” or similar file, you acknowledge and agree that software identified in that file is governed by those separate license terms.
- 
-6. DISCLAIMER, LIMITATION OF LIABILITY. THE SOFTWARE AND ANY DERIVATIVE WORKS THEREOF IS PROVIDED ON AN "AS IS" BASIS, AND IS PROVIDED WITHOUT WARRANTY OF ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR NONINFRINGEMENT. IN NO EVENT SHALL ANY COPYRIGHT HOLDER OR AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES (WHETHER DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL, INCLUDING PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR PROFITS, AND BUSINESS INTERRUPTION), OR OTHER LIABILITY WHATSOEVER, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM OR OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR ANY DERIVATIVE WORKS THEREOF OR THE USE OF OR OTHER DEALINGS IN SAME, EVEN WHERE ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- 
-7. USE IS ACCEPTANCE and License Versions. Your receipt and use of the Software constitutes your acceptance of this License and its terms and conditions. Software released by Unity under this License may be modified or updated and the License with it; upon any such modification or update, you will comply with the terms of the updated License for any use of any of the Software under the updated License. 
- 
-8. Use in Compliance with Law and Termination. Your exercise of the license granted herein will at all times be in compliance with applicable law and will not infringe any proprietary rights (including intellectual property rights); this License will terminate immediately on any breach by you of this License.
-
-9. Severability. If any provision of this License is held to be unenforceable or invalid, that provision will be enforced to the maximum extent possible and the other provisions will remain in full force and effect.
-
-10. Governing Law and Venue. This License is governed by and construed in accordance with the laws of Denmark, except for its conflict of laws rules; the United Nations Convention on Contracts for the International Sale of Goods will not apply. If you reside (or your principal place of business is) within the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the state and federal courts located in San Francisco County, California concerning any dispute arising out of this License (“Dispute”). If you reside (or your principal place of business is) outside the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the courts located in Copenhagen, Denmark concerning any Dispute. 
\ No newline at end of file
+Licensed under the Unity Companion License for Unity-dependent projects (see https://unity3d.com/legal/licenses/unity_companion_license).
+Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.
\ No newline at end of file

From 0534d3a98ccd18c50736cc312af3f3f1467ca5e0 Mon Sep 17 00:00:00 2001
From: Cassandra Lacombe <cassandra@unity3d.com>
Date: Mon, 4 Oct 2021 13:57:40 -0400
Subject: [PATCH 02/94] Package Signature in CI

As part of the package signing initiative, we'd like bundled packages to be prepared for upcoming constraints regarding the need to have packages with a valid signature during APV testing.

Because of this, we are going through all bundled packages' repositories creating a PR that would enable package signing on your packages.

With signing enabled, upm-ci will perform an extra step where it will send each package to a signing service and then generate the final signed artifacts.
Internally, in an attempt to ensure that everything works, we are running yamato tests where all bundled packages (including yours) are signed and validated, proving that the packages in this repository should yield no errors. The validation step is also performed in all platforms.

In the case that any error does arise, this can be simply reverted back by removing the environment variable, UPMCI_ENABLE_PACKAGE_SIGNING in the publishing jobs.

For more information, please refer to: https://confluence.unity3d.com/display/PAK/Package+Signature

You can contact us through:
#team-pkd-176-internal-package-signing
@cassandra & @felipemunoz
---
 .yamato/upm-ci.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.yamato/upm-ci.yml b/.yamato/upm-ci.yml
index ee8ad143..7871afb3 100644
--- a/.yamato/upm-ci.yml
+++ b/.yamato/upm-ci.yml
@@ -116,6 +116,8 @@ publish:
     type: Unity::VM
     image: package-ci/win10:stable
     flavor: b1.large
+  variables:
+    UPMCI_ENABLE_PACKAGE_SIGNING: 1
   commands:
     - npm install upm-ci-utils@stable --registry https://artifactory.prd.cds.internal.unity3d.com/artifactory/api/npm/upm-npm -g
     - upm-ci package publish --package-path src/

From af4f0a33555647a8866bddf84e0e1ac33c678f8b Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Mon, 4 Oct 2021 17:54:45 -0700
Subject: [PATCH 03/94] Merge release/1.2.4 back to master (#198)

Merge release/1.2.4 changes to master. Most changes are CI changes.
---
 .yamato/upm-ci.yml                 | 136 +++++++++++++++++++----------
 LICENSE.md                         |   2 +-
 src/CHANGELOG.md                   |  15 +++-
 src/LICENSE.md                     |  32 +------
 src/Unity.Mathematics/math.cs      |   2 -
 src/ValidationExceptions.json      |   5 ++
 src/ValidationExceptions.json.meta |   7 ++
 src/package.json                   |   2 +-
 8 files changed, 116 insertions(+), 85 deletions(-)
 create mode 100644 src/ValidationExceptions.json
 create mode 100644 src/ValidationExceptions.json.meta

diff --git a/.yamato/upm-ci.yml b/.yamato/upm-ci.yml
index 7871afb3..7abddb97 100644
--- a/.yamato/upm-ci.yml
+++ b/.yamato/upm-ci.yml
@@ -26,37 +26,83 @@ upmci_platforms:
     type: Unity::VM::osx
     flavor: b1.large
 
-editor_versions:
+validate_editor_versions:
   - version: "2018.4"
     display_name: "2018.4"
-  - version: "2019.2"
-    display_name: "2019.2"
-  - version: "2019.3"
-    display_name: "2019.3"
-  - version: "2020.2/partner/staging"
-    display_name: "2020.2_partner_staging"
+  - version: "2019.4"
+    display_name: "2019.4"
+  - version: "2020.3"
+    display_name: "2020.3"
+  - version: "2021.1"
+    display_name: "2021.1"
+  - version: "2021.2"
+    display_name: "2021.2"
+  - version: "2022.1"
+    display_name: "2022.1"
+  - version: "2020.3/partner/staging"
+    display_name: "2020.3_partner_staging"
+  - version: "trunk"
+    display_name: "trunk"
+
+package_tests_editor_versions:
+  # 2018.3 shows up here but not under validate_editor_versions because package validation is no longer
+  # supported on 2018.3 but Mathematics still supports it so we need to be able to test it. CI jobs
+  # from this list will run package tests only instead of the full validation suite.
+  - version: "2018.3"
+    display_name: "2018.3"
+  - version: "2018.4"
+    display_name: "2018.4"
+  - version: "2019.4"
+    display_name: "2019.4"
+  - version: "2020.3"
+    display_name: "2020.3"
+  - version: "2021.1"
+    display_name: "2021.1"
+  - version: "2021.2"
+    display_name: "2021.2"
+  - version: "2022.1"
+    display_name: "2022.1"
+  - version: "2020.3/partner/staging"
+    display_name: "2020.3_partner_staging"
   - version: "trunk"
     display_name: "trunk"
 ---
 
-{% for platform in build_platforms %}
-{% unless platform.name == "linux" %}
-run_tests_on_mono_{{platform.name}}:
-  name: Tests NUnit on {{platform.name}}
+{% for platform in upmci_platforms %}
+{% for editor in package_tests_editor_versions %}
+package_tests_{{platform.name}}_{{editor.display_name}}:
+  name: Package tests {{platform.name}} {{editor.display_name}}
   agent:
-      type: {{platform.type}}
-      image: {{platform.image}}
-      flavor: {{platform.flavor}}
+    image: {{platform.image}}
+    type: {{platform.type}}
+    flavor: {{platform.flavor}}
   commands:
-  {% if platform.name == "windows" %}
-    - choco install nuget.commandline
-  {% endif %}
-    - nuget restore src
-    - msbuild src/Unity.Mathematics.sln
-    - mono src/packages/NUnit.ConsoleRunner.3.9.0/tools/nunit3-console.exe src/Tests/bin/Debug/Unity.Mathematics.Tests.dll --process=single
-{% endunless %}
+    - npm install upm-ci-utils@stable --registry https://artifactory.prd.cds.internal.unity3d.com/artifactory/api/npm/upm-npm -g
+    - upm-ci package pack --package-path src/
+    - upm-ci package test --type package-tests --package-path src/ --unity-version {{ editor.version }}
+  artifacts:
+    test_results:
+      paths:
+          - "upm-ci~/**/*"
+{% endfor %}
 {% endfor %}
 
+package_tests_all:
+  name: Package tests all
+  dependencies:
+    {% for platform in upmci_platforms %}
+    {% for editor in package_tests_editor_versions %}
+    - .yamato/upm-ci.yml#package_tests_{{platform.name}}_{{editor.display_name}}
+    {% endfor %}
+    {% endfor %}
+
+package_tests_minimal:
+  name: Package tests minimal
+  dependencies:
+  {% for platform in upmci_platforms %}
+    - .yamato/upm-ci.yml#package_tests_{{platform.name}}_2018.3
+  {% endfor %}
+
 validate_package_minimal:
   name: Validate Package Linux Minimal
   agent:
@@ -66,7 +112,7 @@ validate_package_minimal:
   commands:
     - npm install upm-ci-utils@stable --registry https://artifactory.prd.cds.internal.unity3d.com/artifactory/api/npm/upm-npm -g
     - upm-ci package pack --package-path src/
-    - upm-ci package test --package-path src/ --unity-version 2019.1
+    - upm-ci package test --package-path src/ --unity-version 2019.4
   artifacts:
     packages:
       paths:
@@ -74,15 +120,9 @@ validate_package_minimal:
     test_results:
       paths:
           - "upm-ci~/**/*"
-  dependencies:
-    {% for platform in build_platforms %}
-    {% unless platform.name == "linux" %}
-    - .yamato/upm-ci.yml#run_tests_on_mono_{{platform.name}}
-    {% endunless %}
-    {% endfor %}
 
-  {% for platform in upmci_platforms %}
-  {% for editor in editor_versions %}
+{% for platform in upmci_platforms %}
+{% for editor in validate_editor_versions %}
 validate_package_{{platform.name}}_{{editor.display_name}}:
   name: Validate package {{platform.name}} {{editor.display_name}}
   agent:
@@ -100,15 +140,17 @@ validate_package_{{platform.name}}_{{editor.display_name}}:
     results_{{platform.name}}_{{editor.display_name}}:
         paths:
             - "upm-ci~/**/*"
+{% endfor %}
+{% endfor %}
+
+validate_package_all:
+  name: Validate package all
   dependencies:
-    {% for platform in build_platforms %}
-    {% unless platform.name == "linux" %}
-    - .yamato/upm-ci.yml#run_tests_on_mono_{{platform.name}}
-    {% endunless %}
+    {% for platform in upmci_platforms %}
+    {% for editor in validate_editor_versions %}
+    - .yamato/upm-ci.yml#validate_package_{{platform.name}}_{{editor.display_name}}
+    {% endfor %}
     {% endfor %}
-  {% endfor %}
-  {% endfor %}
-
 
 publish:
   name: Publish
@@ -126,8 +168,12 @@ publish:
       paths:
         - "upm-ci~/packages/**/*"
   dependencies:
-   - .yamato/upm-ci.yml#validate_package_minimal
-
+    {% for platform in build_platforms %}
+      {% for editor in validate_editor_versions %}
+      - .yamato/upm-ci.yml#validate_package_{{platform.name}}_{{editor.display_name}}
+      {% endfor %}
+    {% endfor %}
+      - .yamato/upm-ci.yml#package_tests_minimal
 
 promote:
   name: Promote
@@ -147,7 +193,6 @@ promote:
   dependencies:
     - .yamato/upm-ci.yml#publish
 
-
 publish_ci:
   name: all Publish Pipeline
   triggers:
@@ -164,18 +209,13 @@ nightly_ci:
       - branch: master
         frequency: daily
   dependencies:
-    {% for platform in build_platforms %}
-      {% for editor in editor_versions %}
-      - .yamato/upm-ci.yml#validate_package_{{platform.name}}_{{editor.display_name}}
-      {% endfor %}
-    {% endfor %}
-
+    - .yamato/upm-ci.yml#validate_package_all
 
 commit_ci:
-  name: all CI pipeline
+  name: Commit CI pipeline
   triggers:
     branches:
       only:
         - "/.*/"
   dependencies:
-    - .yamato/upm-ci.yml#validate_package_minimal
+    - .yamato/upm-ci.yml#package_tests_minimal
diff --git a/LICENSE.md b/LICENSE.md
index c86bf6a7..3ab46903 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,4 +1,4 @@
-Unity.Mathematics © 2019 Unity Technologies
+com.unity.mathematics copyright © 2019 Unity Technologies
 
 Licensed under the Unity Companion License for Unity-dependent projects (see https://unity3d.com/legal/licenses/unity_companion_license).
 Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.
\ No newline at end of file
diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index 7f0d7db1..f58636ca 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -2,22 +2,29 @@
 
 ## [Unreleased]
 ### Added
-* Added `[Il2CppEagerStaticClassConstruction]` to Unity.Mathematics types to run static constructors at startup. This improves IL2CPP performance slightly for types that have static constructors.
 * Added `math.square()` to compute the square (x * x).
 * Added `math.orthonormal_basis()` to compute an orthonormal basis from a single unit length vector.
 * Added `math.sign(x)` for int, int2, int3 and int4.
 
 ### Changed
-* Changed noise documentation in comments to xmldoc comments.
+### Deprecated
+### Removed
+### Fixed
+
+## [1.2.4] - 2021-09-22
+### Added
+* Added `[Il2CppEagerStaticClassConstruction]` to Unity.Mathematics types to run static constructors at startup. This improves IL2CPP performance slightly for types that have static constructors.
 
+### Changed
+* License file updated to satisfy Unity's package validation tests.
+* Changed noise documentation in comments to xmldoc comments.
 ### Deprecated
 ### Removed
 ### Fixed
 * Fixed Equals(object) override which did not check type before casting. This could cause exceptions to be thrown when the object did not match the expected type.
 * Fixed incorrect `math.tzcnt` documentation which mentioned leading zero counts instead of trailing zero counts.
 * Fixed `float2x2.Rotate` documentation to mention radians instead of degrees.
-
-### Internal (Not ready for production)
+* Fixed documentation for methods and properties that were previously undocumented.
 
 ## [1.2.1] - 2020-08-06
 
diff --git a/src/LICENSE.md b/src/LICENSE.md
index 311c9904..3ab46903 100755
--- a/src/LICENSE.md
+++ b/src/LICENSE.md
@@ -1,30 +1,4 @@
-Unity Companion License (“License”)
-Software Copyright © 2019 Unity Technologies ApS 
- 
-Unity Technologies ApS (“Unity”) grants to you a worldwide, non-exclusive, no-charge, and royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute the software that is made available under this License (“Software”), subject to the following terms and conditions: 
- 
-1. Unity Companion Use Only. Exercise of the license granted herein is limited to exercise for the creation, use, and/or distribution of applications, software, or other content pursuant to a valid Unity content authoring and rendering engine software license (“Engine License”). That means while use of the Software is not limited to use in the software licensed under the Engine License, the Software may not be used for any purpose other than the creation, use, and/or distribution of Engine License-dependent applications, software, or other content. No other exercise of the license granted herein is permitted, and in no event may the Software be used for competitive analysis or to develop a competing product or service.
- 
-2. No Modification of Engine License. Neither this License nor any exercise of the license granted herein modifies the Engine License in any way.
- 
-3. Ownership & Grant Back to You. 
+com.unity.mathematics copyright © 2019 Unity Technologies
 
-3.1 You own your content. In this License, “derivative works” means derivatives of the Software itself--works derived only from the Software by you under this License (for example, modifying the code of the Software itself to improve its efficacy); “derivative works” of the Software do not include, for example, games, apps, or content that you create using the Software. You keep all right, title, and interest to your own content.
-
-3.2 Unity owns its content. While you keep all right, title, and interest to your own content per the above, as between Unity and you, Unity will own all right, title, and interest to all intellectual property rights (including patent, trademark, and copyright) in the Software and derivative works of the Software, and you hereby assign and agree to assign all such rights in those derivative works to Unity. 
-
-3.3 You have a license to those derivative works. Subject to this License, Unity grants to you the same worldwide, non-exclusive, no-charge, and royalty-free copyright license to derivative works of the Software you create as is granted to you for the Software under this License.
- 
-4. Trademarks. You are not granted any right or license under this License to use any trademarks, service marks, trade names, products names, or branding of Unity or its affiliates (“Trademarks”). Descriptive uses of Trademarks are permitted; see, for example, Unity’s Branding Usage Guidelines at https://unity3d.com/public-relations/brand.
- 
-5. Notices & Third-Party Rights. This License, including the copyright notice associated with the Software, must be provided in all substantial portions of the Software and derivative works thereof (or, if that is impracticable, in any other location where such notices are customarily placed). Further, if the Software is accompanied by a Unity “third-party notices” or similar file, you acknowledge and agree that software identified in that file is governed by those separate license terms.
- 
-6. DISCLAIMER, LIMITATION OF LIABILITY. THE SOFTWARE AND ANY DERIVATIVE WORKS THEREOF IS PROVIDED ON AN "AS IS" BASIS, AND IS PROVIDED WITHOUT WARRANTY OF ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR NONINFRINGEMENT. IN NO EVENT SHALL ANY COPYRIGHT HOLDER OR AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES (WHETHER DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL, INCLUDING PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR PROFITS, AND BUSINESS INTERRUPTION), OR OTHER LIABILITY WHATSOEVER, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM OR OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR ANY DERIVATIVE WORKS THEREOF OR THE USE OF OR OTHER DEALINGS IN SAME, EVEN WHERE ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- 
-7. USE IS ACCEPTANCE and License Versions. Your receipt and use of the Software constitutes your acceptance of this License and its terms and conditions. Software released by Unity under this License may be modified or updated and the License with it; upon any such modification or update, you will comply with the terms of the updated License for any use of any of the Software under the updated License. 
- 
-8. Use in Compliance with Law and Termination. Your exercise of the license granted herein will at all times be in compliance with applicable law and will not infringe any proprietary rights (including intellectual property rights); this License will terminate immediately on any breach by you of this License.
-
-9. Severability. If any provision of this License is held to be unenforceable or invalid, that provision will be enforced to the maximum extent possible and the other provisions will remain in full force and effect.
-
-10. Governing Law and Venue. This License is governed by and construed in accordance with the laws of Denmark, except for its conflict of laws rules; the United Nations Convention on Contracts for the International Sale of Goods will not apply. If you reside (or your principal place of business is) within the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the state and federal courts located in San Francisco County, California concerning any dispute arising out of this License (“Dispute”). If you reside (or your principal place of business is) outside the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the courts located in Copenhagen, Denmark concerning any Dispute. 
\ No newline at end of file
+Licensed under the Unity Companion License for Unity-dependent projects (see https://unity3d.com/legal/licenses/unity_companion_license).
+Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.
\ No newline at end of file
diff --git a/src/Unity.Mathematics/math.cs b/src/Unity.Mathematics/math.cs
index 3400cc01..ad464d7d 100644
--- a/src/Unity.Mathematics/math.cs
+++ b/src/Unity.Mathematics/math.cs
@@ -2627,7 +2627,6 @@ public static bool4 ispow2(uint4 x)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static double4 rcp(double4 x) { return 1.0 / x; }
 
-
         /// <summary>Returns the sign of a int value. -1 if it is less than zero, 0 if it is zero and 1 if it greater than zero.</summary>
         /// <param name="x">Input value.</param>
         /// <returns>The sign of the input.</returns>
@@ -2652,7 +2651,6 @@ public static bool4 ispow2(uint4 x)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int4 sign(int4 x) { return new int4(sign(x.x), sign(x.y), sign(x.z), sign(x.w)); }
 
-
         /// <summary>Returns the sign of a float value. -1.0f if it is less than zero, 0.0f if it is zero and 1.0f if it greater than zero.</summary>
         /// <param name="x">Input value.</param>
         /// <returns>The sign of the input.</returns>
diff --git a/src/ValidationExceptions.json b/src/ValidationExceptions.json
new file mode 100644
index 00000000..e8a81512
--- /dev/null
+++ b/src/ValidationExceptions.json
@@ -0,0 +1,5 @@
+{
+    "ErrorExceptions": [
+    ],
+    "WarningExceptions": []
+}
\ No newline at end of file
diff --git a/src/ValidationExceptions.json.meta b/src/ValidationExceptions.json.meta
new file mode 100644
index 00000000..e0483f02
--- /dev/null
+++ b/src/ValidationExceptions.json.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 5ed727127196a4ecc90e24e2cd7af338
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/src/package.json b/src/package.json
index ac714659..da1a2f7c 100755
--- a/src/package.json
+++ b/src/package.json
@@ -1,7 +1,7 @@
 {
     "name": "com.unity.mathematics",
     "displayName": "Mathematics",
-    "version": "1.2.1",
+    "version": "1.2.4",
     "unity": "2018.3",
     "description": "Unity's C# SIMD math library providing vector types and math functions with a shader like syntax.",
     "keywords": [

From 4a1d9dff0feb4b91699d118406a145505aa3c1cd Mon Sep 17 00:00:00 2001
From: Fabrizio Perria <fabrizio@unity3d.com>
Date: Wed, 20 Oct 2021 10:54:07 +0200
Subject: [PATCH 04/94] Provide runtime identifier

---
 src/Unity.Mathematics/Unity.Mathematics.csproj | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj
index 11383fbb..fa59d06c 100644
--- a/src/Unity.Mathematics/Unity.Mathematics.csproj
+++ b/src/Unity.Mathematics/Unity.Mathematics.csproj
@@ -11,6 +11,7 @@
     <RootNamespace>Unity</RootNamespace>
     <AssemblyName>Unity.Mathematics</AssemblyName>
     <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>
+    <RuntimeIdentifier>win</RuntimeIdentifier>
     <FileAlignment>512</FileAlignment>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

From 4f846b8ce86bddf054c771e3940eeed92000c5a3 Mon Sep 17 00:00:00 2001
From: Fabrizio Perria <fabrizio@unity3d.com>
Date: Wed, 20 Oct 2021 11:42:40 +0200
Subject: [PATCH 05/94] Revert "Provide runtime identifier"

This reverts commit 4a1d9dff0feb4b91699d118406a145505aa3c1cd.
---
 src/Unity.Mathematics/Unity.Mathematics.csproj | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj
index fa59d06c..11383fbb 100644
--- a/src/Unity.Mathematics/Unity.Mathematics.csproj
+++ b/src/Unity.Mathematics/Unity.Mathematics.csproj
@@ -11,7 +11,6 @@
     <RootNamespace>Unity</RootNamespace>
     <AssemblyName>Unity.Mathematics</AssemblyName>
     <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>
-    <RuntimeIdentifier>win</RuntimeIdentifier>
     <FileAlignment>512</FileAlignment>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

From 6c978302ee98bcebadc69a9e8ddb039a8a33f70c Mon Sep 17 00:00:00 2001
From: Fabrizio Perria <fabrizio@unity3d.com>
Date: Wed, 20 Oct 2021 11:43:20 +0200
Subject: [PATCH 06/94] recover burst compatibility

---
 src/Tests/Unity.Mathematics.Tests.csproj      |   2 +-
 src/Unity.Mathematics.sln                     |   8 +-
 src/Unity.Mathematics/Geometry/MinMaxAABB.cs  |   4 +-
 src/Unity.Mathematics/Geometry/Plane.cs       |   2 +-
 .../Properties/AssemblyInfo.cs                |  47 -----
 .../Unity.Mathematics.csproj                  | 163 ++----------------
 6 files changed, 18 insertions(+), 208 deletions(-)
 delete mode 100644 src/Unity.Mathematics/Properties/AssemblyInfo.cs

diff --git a/src/Tests/Unity.Mathematics.Tests.csproj b/src/Tests/Unity.Mathematics.Tests.csproj
index 4ca36bde..7d9e0d5c 100644
--- a/src/Tests/Unity.Mathematics.Tests.csproj
+++ b/src/Tests/Unity.Mathematics.Tests.csproj
@@ -103,7 +103,7 @@
     <Compile Include="Tests\Shared\TestMath.gen.cs" />
     <Compile Include="Tests\Shared\TestMatrix.cs" />
     <Compile Include="Tests\Shared\TestMinMaxAABB.cs" />
-    <Compile Include="Tests\Shared\TestPlane.cs" />
+    <Compile Include="Tests\Shared\TestPlane.cs" / >
     <Compile Include="Tests\Shared\TestQuaternion.cs" />
     <Compile Include="Tests\Shared\TestRigidTransform.cs" />
     <Compile Include="Tests\TestMath2.cs" />
diff --git a/src/Unity.Mathematics.sln b/src/Unity.Mathematics.sln
index 19d5c88a..2e4dadd0 100644
--- a/src/Unity.Mathematics.sln
+++ b/src/Unity.Mathematics.sln
@@ -28,14 +28,14 @@ Global
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 		{19810344-7387-4155-935F-BDD5CC61F0BF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{19810344-7387-4155-935F-BDD5CC61F0BF}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{19810344-7387-4155-935F-BDD5CC61F0BF}.Debug|x64.ActiveCfg = Debug|x64
-		{19810344-7387-4155-935F-BDD5CC61F0BF}.Debug|x64.Build.0 = Debug|x64
+		{19810344-7387-4155-935F-BDD5CC61F0BF}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{19810344-7387-4155-935F-BDD5CC61F0BF}.Debug|x64.Build.0 = Debug|Any CPU
 		{19810344-7387-4155-935F-BDD5CC61F0BF}.Debug|x86.ActiveCfg = Debug|Any CPU
 		{19810344-7387-4155-935F-BDD5CC61F0BF}.Debug|x86.Build.0 = Debug|Any CPU
 		{19810344-7387-4155-935F-BDD5CC61F0BF}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{19810344-7387-4155-935F-BDD5CC61F0BF}.Release|Any CPU.Build.0 = Release|Any CPU
-		{19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x64.ActiveCfg = Release|x64
-		{19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x64.Build.0 = Release|x64
+		{19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x64.ActiveCfg = Release|Any CPU
+		{19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x64.Build.0 = Release|Any CPU
 		{19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x86.ActiveCfg = Release|Any CPU
 		{19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x86.Build.0 = Release|Any CPU
 		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
diff --git a/src/Unity.Mathematics/Geometry/MinMaxAABB.cs b/src/Unity.Mathematics/Geometry/MinMaxAABB.cs
index eb4a3876..6b5b666d 100644
--- a/src/Unity.Mathematics/Geometry/MinMaxAABB.cs
+++ b/src/Unity.Mathematics/Geometry/MinMaxAABB.cs
@@ -16,7 +16,7 @@ namespace Unity.Mathematics.Geometry
     /// </remarks>
     [System.Serializable]
     [Il2CppEagerStaticClassConstruction]
-    internal struct MinMaxAABB : IEquatable<MinMaxAABB>
+    public struct MinMaxAABB : IEquatable<MinMaxAABB>
     {
         /// <summary>
         /// The minimum point contained by the AABB.
@@ -213,7 +213,7 @@ public override string ToString()
         }
     }
 
-    internal static partial class Math
+    public static partial class Math
     {
         /// <summary>
         /// Transforms the AABB with the given transform.
diff --git a/src/Unity.Mathematics/Geometry/Plane.cs b/src/Unity.Mathematics/Geometry/Plane.cs
index 92d47c5e..5094bb94 100644
--- a/src/Unity.Mathematics/Geometry/Plane.cs
+++ b/src/Unity.Mathematics/Geometry/Plane.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Geometry
     [DebuggerDisplay("{Normal}, {Distance}")]
     [Serializable]
     [Il2CppEagerStaticClassConstruction]
-    internal struct Plane
+    public struct Plane
     {
         /// <summary>
         /// A plane in the form Ax + By + Cz + Dw = 0.
diff --git a/src/Unity.Mathematics/Properties/AssemblyInfo.cs b/src/Unity.Mathematics/Properties/AssemblyInfo.cs
deleted file mode 100644
index c090f5b4..00000000
--- a/src/Unity.Mathematics/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-#if !UNITY_DOTSPLAYER
-using System.Reflection;
-
-// General Information about an assembly is controlled through the following
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-
-[assembly: AssemblyTitle("Unity.Mathematics")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("Unity.Mathematics")]
-[assembly: AssemblyCopyright("Copyright ©  2017")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Setting ComVisible to false makes the types in this assembly not visible
-// to COM components.  If you need to access a type in this assembly from
-// COM, set the ComVisible attribute to true on that type.
-
-[assembly: ComVisible(false)]
-
-// The following GUID is for the ID of the typelib if this project is exposed to COM
-
-[assembly: Guid("19810344-7387-4155-935F-BDD5CC61F0BF")]
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
-#endif
-
-[assembly: InternalsVisibleTo("Unity.Mathematics.Tests")]
-[assembly: InternalsVisibleTo("Unity.Mathematics.PerformanceTests")]
-[assembly: InternalsVisibleTo("btests")]
\ No newline at end of file
diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj
index 11383fbb..43ae5cc1 100644
--- a/src/Unity.Mathematics/Unity.Mathematics.csproj
+++ b/src/Unity.Mathematics/Unity.Mathematics.csproj
@@ -1,162 +1,19 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{19810344-7387-4155-935F-BDD5CC61F0BF}</ProjectGuid>
-    <ProjectTypeGuids>{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>Unity</RootNamespace>
-    <AssemblyName>Unity.Mathematics</AssemblyName>
-    <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>..\..\build\bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>..\..\build\bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>..\..\build\bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <TargetFramework>net471</TargetFramework>
     <PlatformTarget>AnyCPU</PlatformTarget>
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>..\..\build\bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <OutputPath>..\..\build\bin\$(Configuration)\</OutputPath>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="System" />
+    <Compile Remove="math_unity_conversion.cs" />
+    <Compile Remove="PropertyAttributes.cs" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="bool2.gen.cs" />
-    <Compile Include="bool2x2.gen.cs" />
-    <Compile Include="bool2x3.gen.cs" />
-    <Compile Include="bool2x4.gen.cs" />
-    <Compile Include="bool3.gen.cs" />
-    <Compile Include="bool3x2.gen.cs" />
-    <Compile Include="bool3x3.gen.cs" />
-    <Compile Include="bool3x4.gen.cs" />
-    <Compile Include="bool4.gen.cs" />
-    <Compile Include="bool4x2.gen.cs" />
-    <Compile Include="bool4x3.gen.cs" />
-    <Compile Include="bool4x4.gen.cs" />
-    <Compile Include="double2.gen.cs" />
-    <Compile Include="double2x2.gen.cs" />
-    <Compile Include="double2x3.gen.cs" />
-    <Compile Include="double2x4.gen.cs" />
-    <Compile Include="double3.gen.cs" />
-    <Compile Include="double3x2.gen.cs" />
-    <Compile Include="double3x3.gen.cs" />
-    <Compile Include="double3x4.gen.cs" />
-    <Compile Include="double4.gen.cs" />
-    <Compile Include="double4x2.gen.cs" />
-    <Compile Include="double4x3.gen.cs" />
-    <Compile Include="double4x4.gen.cs" />
-    <Compile Include="Geometry\MinMaxAABB.cs" />
-    <Compile Include="Geometry\Plane.cs" />
-    <Compile Include="float2.gen.cs" />
-    <Compile Include="float2x2.gen.cs" />
-    <Compile Include="float2x3.gen.cs" />
-    <Compile Include="float2x4.gen.cs" />
-    <Compile Include="float3.gen.cs" />
-    <Compile Include="float3x2.gen.cs" />
-    <Compile Include="float3x3.gen.cs" />
-    <Compile Include="float3x4.gen.cs" />
-    <Compile Include="float4.gen.cs" />
-    <Compile Include="float4x2.gen.cs" />
-    <Compile Include="float4x3.gen.cs" />
-    <Compile Include="float4x4.gen.cs" />
-    <Compile Include="half.cs" />
-    <Compile Include="half2.gen.cs" />
-    <Compile Include="half3.gen.cs" />
-    <Compile Include="half4.gen.cs" />
-    <Compile Include="Il2CppEagerStaticClassConstructionAttribute.cs" />
-    <Compile Include="int2x2.gen.cs" />
-    <Compile Include="int2x3.gen.cs" />
-    <Compile Include="int2x4.gen.cs" />
-    <Compile Include="int3x2.gen.cs" />
-    <Compile Include="int3x3.gen.cs" />
-    <Compile Include="int3x4.gen.cs" />
-    <Compile Include="int4x2.gen.cs" />
-    <Compile Include="int4x3.gen.cs" />
-    <Compile Include="int4x4.gen.cs" />
-    <Compile Include="math.cs" />
-    <Compile Include="int2.gen.cs" />
-    <Compile Include="int3.gen.cs" />
-    <Compile Include="int4.gen.cs" />
-    <Compile Include="matrix.cs" />
-    <Compile Include="matrix.gen.cs" />
-    <Compile Include="Noise\cellular2D.cs" />
-    <Compile Include="Noise\cellular2x2.cs" />
-    <Compile Include="Noise\cellular2x2x2.cs" />
-    <Compile Include="Noise\cellular3D.cs" />
-    <Compile Include="Noise\classicnoise2D.cs" />
-    <Compile Include="Noise\classicnoise3D.cs" />
-    <Compile Include="Noise\classicnoise4D.cs" />
-    <Compile Include="Noise\common.cs" />
-    <Compile Include="Noise\noise2D.cs" />
-    <Compile Include="Noise\noise3D.cs" />
-    <Compile Include="Noise\noise3Dgrad.cs" />
-    <Compile Include="Noise\noise4D.cs" />
-    <Compile Include="Noise\psrdnoise2D.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="quaternion.cs" />
-    <Compile Include="rigid_transform.cs" />
-    <Compile Include="random.cs" />
-    <Compile Include="uint2.gen.cs" />
-    <Compile Include="uint2x2.gen.cs" />
-    <Compile Include="uint2x3.gen.cs" />
-    <Compile Include="uint2x4.gen.cs" />
-    <Compile Include="uint3.gen.cs" />
-    <Compile Include="uint3x2.gen.cs" />
-    <Compile Include="uint3x3.gen.cs" />
-    <Compile Include="uint3x4.gen.cs" />
-    <Compile Include="uint4.gen.cs" />
-    <Compile Include="uint4x2.gen.cs" />
-    <Compile Include="uint4x3.gen.cs" />
-    <Compile Include="uint4x4.gen.cs" />
+        <!-- Allows targeting net471 on non-Windows platforms -->
+        <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
+
   </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
+  <ItemGroup />
 </Project>
\ No newline at end of file

From 0a19cfed4bec15aebf0d4365ecb91308464a07c4 Mon Sep 17 00:00:00 2001
From: Alexandre Mutel <alexandre@unity3d.com>
Date: Thu, 2 Jul 2020 12:03:09 +0200
Subject: [PATCH 07/94] Fix Unity.Mathematics to stay on version 1.0.0.0

---
 src/Unity.Mathematics/Unity.Mathematics.csproj | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj
index 43ae5cc1..f4c7c4e6 100644
--- a/src/Unity.Mathematics/Unity.Mathematics.csproj
+++ b/src/Unity.Mathematics/Unity.Mathematics.csproj
@@ -5,6 +5,8 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
     <OutputPath>..\..\build\bin\$(Configuration)\</OutputPath>
+    <!--Version must remain to 1.0.0.0 for Burst unit tests-->
+    <Version>1.0.0.0</Version> 
   </PropertyGroup>
   <ItemGroup>
     <Compile Remove="math_unity_conversion.cs" />

From 5b4fc08f44cf57001c8086e73f6619e0b9b8bddd Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Mon, 1 Nov 2021 11:23:54 -0700
Subject: [PATCH 08/94] DOTS-5107: Fix vector drawing in the inspector. (#199)

Fix property drawing in the inspector when manually drawing a property that was hidden with `[HideInInspector]`.
---
 src/CHANGELOG.md                              |   1 +
 .../PrimitiveVectorDrawer.cs                  | 147 +++++++++++++++++-
 2 files changed, 146 insertions(+), 2 deletions(-)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index f58636ca..027ec284 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -10,6 +10,7 @@
 ### Deprecated
 ### Removed
 ### Fixed
+* Fixed property drawing when manually drawing a property that was hidden with [HideInInspector].
 
 ## [1.2.4] - 2021-09-22
 ### Added
diff --git a/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs b/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs
index d84d81f9..28d8f47f 100644
--- a/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs
+++ b/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs
@@ -89,9 +89,152 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
             if (attribute is DoNotNormalizeAttribute && string.IsNullOrEmpty(label.tooltip))
                 label.tooltip = Content.doNotNormalizeTooltip;
 
-            EditorGUI.BeginProperty(position, label, property);
-            EditorGUI.MultiPropertyField(position, subLabels, property.FindPropertyRelative(startIter), label);
+            label = EditorGUI.BeginProperty(position, label, property);
+            var valuesIterator = property.FindPropertyRelative(startIter);
+            MultiPropertyField(position, subLabels, valuesIterator, label);
             EditorGUI.EndProperty();
         }
+
+        void MultiPropertyField(Rect position, GUIContent[] subLabels, SerializedProperty valuesIterator, GUIContent label)
+        {
+#if UNITY_2022_1_OR_NEWER
+            EditorGUI.MultiPropertyField(position, subLabels, valuesIterator, label, EditorGUI.PropertyVisibility.All);
+#else
+            EditorGUICopy.MultiPropertyField(position, subLabels, valuesIterator, label);
+#endif
+        }
+    }
+
+#if !UNITY_2022_1_OR_NEWER
+    internal class EditorGUICopy
+    {
+        internal const float kSpacingSubLabel = 4;
+        private const float kIndentPerLevel = 15;
+        internal const float kPrefixPaddingRight = 2;
+        internal static int indentLevel = 0;
+        private static readonly int s_FoldoutHash = "Foldout".GetHashCode();
+
+        // internal static readonly SVC<float> kVerticalSpacingMultiField = new SVC<float>("--theme-multifield-vertical-spacing", 0.0f);
+        // kVerticalSpacingMultiField should actually look like the above line ^^^ but we don't have access to SVC<T>,
+        // so instead we just set this value to what is observed in the debugger with the Unity dark theme.
+        internal const float kVerticalSpacingMultiField = 2;
+
+        internal enum PropertyVisibility
+        {
+            All,
+            OnlyVisible
+        }
+
+        // This code is basically EditorGUI.MultiPropertyField(Rect, GUIContent[], SerializedProperty, GUIContent),
+        // but with the property visibility assumed to be "All" instead of "OnlyVisible". We really want to have "All"
+        // because it's possible for someone to hide something in the inspector with [HideInInspector] but then manually
+        // draw it themselves later. In this case, if you called EditorGUI.MultiPropertyField() directly, you'd
+        // end up with some fields that point to some unrelated visible property.
+        public static void MultiPropertyField(Rect position, GUIContent[] subLabels, SerializedProperty valuesIterator, GUIContent label)
+        {
+            int id = GUIUtility.GetControlID(s_FoldoutHash, FocusType.Keyboard, position);
+            position = MultiFieldPrefixLabel(position, id, label, subLabels.Length);
+            position.height = EditorGUIUtility.singleLineHeight;
+            MultiPropertyFieldInternal(position, subLabels, valuesIterator, PropertyVisibility.All);
+        }
+
+        internal static void BeginDisabled(bool disabled)
+        {
+            // Unused, but left here to minimize changes in EditorGUICopy.MultiPropertyFieldInternal().
+        }
+
+        internal static void EndDisabled()
+        {
+            // Unused, but left here to minimize changes in EditorGUICopy.MultiPropertyFieldInternal().
+        }
+
+        internal static float CalcPrefixLabelWidth(GUIContent label, GUIStyle style = null)
+        {
+            if (style == null)
+                style = EditorStyles.label;
+            return style.CalcSize(label).x;
+        }
+
+        internal static void MultiPropertyFieldInternal(Rect position, GUIContent[] subLabels, SerializedProperty valuesIterator, PropertyVisibility visibility, bool[] disabledMask = null, float prefixLabelWidth = -1)
+        {
+            int eCount = subLabels.Length;
+            float w = (position.width - (eCount - 1) * kSpacingSubLabel) / eCount;
+            Rect nr = new Rect(position) {width = w};
+            float t = EditorGUIUtility.labelWidth;
+            int l = indentLevel;
+            indentLevel = 0;
+            for (int i = 0; i < subLabels.Length; i++)
+            {
+                EditorGUIUtility.labelWidth = prefixLabelWidth > 0 ? prefixLabelWidth : CalcPrefixLabelWidth(subLabels[i]);
+
+                if (disabledMask != null)
+                    BeginDisabled(disabledMask[i]);
+                EditorGUI.PropertyField(nr, valuesIterator, subLabels[i]);
+                if (disabledMask != null)
+                    EndDisabled();
+                nr.x += w + kSpacingSubLabel;
+
+                switch (visibility)
+                {
+                    case PropertyVisibility.All:
+                        valuesIterator.Next(false);
+                        break;
+
+                    case PropertyVisibility.OnlyVisible:
+                        valuesIterator.NextVisible(false);
+                        break;
+                }
+            }
+            EditorGUIUtility.labelWidth = t;
+            indentLevel = l;
+        }
+
+        internal static bool LabelHasContent(GUIContent label)
+        {
+            if (label == null)
+            {
+                return true;
+            }
+            // @TODO: find out why checking for GUIContent.none doesn't work
+            return label.text != string.Empty || label.image != null;
+        }
+
+        internal static float indent => indentLevel * kIndentPerLevel;
+
+        internal static Rect MultiFieldPrefixLabel(Rect totalPosition, int id, GUIContent label, int columns)
+        {
+            if (!LabelHasContent(label))
+            {
+                return EditorGUI.IndentedRect(totalPosition);
+            }
+
+            if (EditorGUIUtility.wideMode)
+            {
+                Rect labelPosition = new Rect(totalPosition.x + indent, totalPosition.y, EditorGUIUtility.labelWidth - indent, EditorGUIUtility.singleLineHeight);
+                Rect fieldPosition = totalPosition;
+                fieldPosition.xMin += EditorGUIUtility.labelWidth + kPrefixPaddingRight;
+
+                // If there are 2 columns we use the same column widths as if there had been 3 columns
+                // in order to make columns line up neatly.
+                if (columns == 2)
+                {
+                    float columnWidth = (fieldPosition.width - (3 - 1) * kSpacingSubLabel) / 3f;
+                    fieldPosition.xMax -= (columnWidth + kSpacingSubLabel);
+                }
+
+                EditorGUI.HandlePrefixLabel(totalPosition, labelPosition, label, id);
+                return fieldPosition;
+            }
+            else
+            {
+                Rect labelPosition = new Rect(totalPosition.x + indent, totalPosition.y, totalPosition.width - indent, EditorGUIUtility.singleLineHeight);
+                Rect fieldPosition = totalPosition;
+                fieldPosition.xMin += indent + kIndentPerLevel;
+                fieldPosition.yMin += EditorGUIUtility.singleLineHeight + kVerticalSpacingMultiField;
+                EditorGUI.HandlePrefixLabel(totalPosition, labelPosition, label, id);
+                return fieldPosition;
+            }
+        }
     }
+#endif
 }

From e5b7df1d758d901825b3465757cff88aea72b0d3 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Fri, 12 Nov 2021 16:18:39 -0800
Subject: [PATCH 09/94] Merge back 1.2.5 to master (#202)

Merging changelog and package.json after releasing 1.2.5.
---
 src/CHANGELOG.md | 7 ++++++-
 src/package.json | 2 +-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index 027ec284..f780369d 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -5,7 +5,13 @@
 * Added `math.square()` to compute the square (x * x).
 * Added `math.orthonormal_basis()` to compute an orthonormal basis from a single unit length vector.
 * Added `math.sign(x)` for int, int2, int3 and int4.
+### Changed
+### Deprecated
+### Removed
+### Fixed
 
+## [1.2.5] - 2021-11-01
+### Added
 ### Changed
 ### Deprecated
 ### Removed
@@ -15,7 +21,6 @@
 ## [1.2.4] - 2021-09-22
 ### Added
 * Added `[Il2CppEagerStaticClassConstruction]` to Unity.Mathematics types to run static constructors at startup. This improves IL2CPP performance slightly for types that have static constructors.
-
 ### Changed
 * License file updated to satisfy Unity's package validation tests.
 * Changed noise documentation in comments to xmldoc comments.
diff --git a/src/package.json b/src/package.json
index da1a2f7c..21c041d3 100755
--- a/src/package.json
+++ b/src/package.json
@@ -1,7 +1,7 @@
 {
     "name": "com.unity.mathematics",
     "displayName": "Mathematics",
-    "version": "1.2.4",
+    "version": "1.2.5",
     "unity": "2018.3",
     "description": "Unity's C# SIMD math library providing vector types and math functions with a shader like syntax.",
     "keywords": [

From 4528bab5e33afd1956f5acca564d05b89e6d4fd8 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Mon, 22 Nov 2021 14:09:48 -0800
Subject: [PATCH 10/94] Make performance tests create a variable for iteration
 count. (#205)

While the performance tests worked just fine, it was annoying to hand
modify a performance test when investigating performance issues. You
had to search the code for all instances of a const literal and be
sure you changed the number in all those places. Instead, use a
variable so you can change it in one place.
---
 .../VectorGenerator.cs                        |   7 +-
 .../TestConversions.gen.cs                    | 116 +++++++------
 .../TestFastInverse.gen.cs                    |  16 +-
 .../TestHash.gen.cs                           | 156 ++++++++++--------
 .../TestInverse.gen.cs                        |  56 ++++---
 .../TestMath.gen.cs                           |  40 +++--
 .../TestMinMaxAABB.gen.cs                     |  16 +-
 .../TestMul.gen.cs                            |  84 ++++++----
 .../TestNoise.gen.cs                          | 148 ++++++++++-------
 .../TestNormalize.gen.cs                      |  96 +++++++----
 .../TestPlane.gen.cs                          |   8 +-
 .../TestRandom.gen.cs                         | 144 +++++++++-------
 .../TestRotation.gen.cs                       | 108 ++++++------
 .../TestShuffle.gen.cs                        |  48 +++---
 .../TestTranspose.gen.cs                      |  48 ++++--
 .../TestTrig.gen.cs                           |  48 +++---
 16 files changed, 675 insertions(+), 464 deletions(-)

diff --git a/src/Unity.Mathematics.CodeGen/VectorGenerator.cs b/src/Unity.Mathematics.CodeGen/VectorGenerator.cs
index 35d58e12..74ca911d 100644
--- a/src/Unity.Mathematics.CodeGen/VectorGenerator.cs
+++ b/src/Unity.Mathematics.CodeGen/VectorGenerator.cs
@@ -3722,6 +3722,7 @@ void GeneratePerformanceTest(StringBuilder str, string testName, PerformanceTest
             str.AppendFormat("\t\t[BurstCompile(CompileSynchronously = true)]\n");
             str.AppendFormat("\t\tpublic unsafe class {0}\n", testName);
             str.AppendFormat("\t\t{{\n");
+            str.AppendFormat("\t\t\tpublic const int iterations = {0};\n\n", loopIterations);
             str.AppendFormat("\t\t\tpublic struct Arguments : IDisposable\n");
             str.AppendFormat("\t\t\t{{\n");
 
@@ -3736,8 +3737,8 @@ void GeneratePerformanceTest(StringBuilder str, string testName, PerformanceTest
 
             foreach (var argument in testArguments)
             {
-                str.AppendFormat("\t\t\t\t\t{0} = ({1}*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<{1}>() * {2}, UnsafeUtility.AlignOf<{1}>(), Allocator.Persistent);\n", argument.m_MemberName, argument.m_ElementType, loopIterations);
-                str.AppendFormat("\t\t\t\t\tfor (int i = 0; i < {0}; ++i)\n", loopIterations);
+                str.AppendFormat("\t\t\t\t\t{0} = ({1}*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<{1}>() * iterations, UnsafeUtility.AlignOf<{1}>(), Allocator.Persistent);\n", argument.m_MemberName, argument.m_ElementType);
+                str.AppendFormat("\t\t\t\t\tfor (int i = 0; i < iterations; ++i)\n");
                 str.AppendFormat("\t\t\t\t\t{{\n");
                 str.AppendFormat("\t\t\t\t\t    {0}[i] = {1};\n", argument.m_MemberName, argument.m_ElementInitializer);
                 str.AppendFormat("\t\t\t\t\t}}\n\n");
@@ -3758,7 +3759,7 @@ void GeneratePerformanceTest(StringBuilder str, string testName, PerformanceTest
 
             str.AppendFormat("\t\t\tpublic static void CommonTestFunction(ref Arguments args)\n");
             str.AppendFormat("\t\t\t{{\n");
-            str.AppendFormat("\t\t\t\tfor (int i = 0; i < {0}; ++i)\n", loopIterations);
+            str.AppendFormat("\t\t\t\tfor (int i = 0; i < iterations; ++i)\n");
             str.AppendFormat("\t\t\t\t{{\n");
             str.AppendFormat("\t\t\t\t\t{0}\n", loopBody);
             str.AppendFormat("\t\t\t\t}}\n");
diff --git a/src/Unity.Mathematics.PerformanceTests/TestConversions.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestConversions.gen.cs
index 08266759..20193726 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestConversions.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestConversions.gen.cs
@@ -21,6 +21,8 @@ partial class TestConversions
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class quaternion_to_float3x3
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public quaternion* q;
@@ -28,14 +30,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * 10000, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         q[i] = quaternion.identity;
                     }
 
-                    f3x3 = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * 10000, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f3x3 = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f3x3[i] = float3x3.identity;
                     }
@@ -51,7 +53,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.f3x3[i] = new float3x3(args.q[i]);
                 }
@@ -109,6 +111,8 @@ public void quaternion_to_float3x3_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float3x3_to_quaternion
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public quaternion* q;
@@ -116,14 +120,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * 10000, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         q[i] = quaternion.identity;
                     }
 
-                    f3x3 = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * 10000, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f3x3 = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f3x3[i] = float3x3.identity;
                     }
@@ -139,7 +143,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.q[i] = new quaternion(args.f3x3[i]);
                 }
@@ -197,6 +201,8 @@ public void float3x3_to_quaternion_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4_to_half4
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float4* f4;
@@ -204,14 +210,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    f4 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 10000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f4 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f4[i] = new float4(1.0f, 2.0f, 3.0f, 4.0f);
                     }
 
-                    h4 = (half4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<half4>() * 10000, UnsafeUtility.AlignOf<half4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    h4 = (half4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<half4>() * iterations, UnsafeUtility.AlignOf<half4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         h4[i] = new half4(new float4(-1.0f, -2.0f, -3.0f, -4.0f));
                     }
@@ -227,7 +233,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.h4[i] = new half4(args.f4[i]);
                 }
@@ -285,6 +291,8 @@ public void float4_to_half4_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class half4_to_float4
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float4* f4;
@@ -292,14 +300,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    f4 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 10000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f4 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f4[i] = new float4(1.0f, 2.0f, 3.0f, 4.0f);
                     }
 
-                    h4 = (half4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<half4>() * 10000, UnsafeUtility.AlignOf<half4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    h4 = (half4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<half4>() * iterations, UnsafeUtility.AlignOf<half4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         h4[i] = new half4(new float4(-1.0f, -2.0f, -3.0f, -4.0f));
                     }
@@ -315,7 +323,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.f4[i] = new float4(args.h4[i]);
                 }
@@ -373,6 +381,8 @@ public void half4_to_float4_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class quaternion_to_RigidTransform
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public quaternion* q;
@@ -381,20 +391,20 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * 10000, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         q[i] = quaternion.identity;
                     }
 
-                    rt = (RigidTransform*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<RigidTransform>() * 10000, UnsafeUtility.AlignOf<RigidTransform>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    rt = (RigidTransform*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<RigidTransform>() * iterations, UnsafeUtility.AlignOf<RigidTransform>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         rt[i] = RigidTransform.identity;
                     }
 
-                    pos = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    pos = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         pos[i] = new float3();
                     }
@@ -411,7 +421,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.rt[i] = new RigidTransform(args.q[i], args.pos[i]);
                 }
@@ -469,6 +479,8 @@ public void quaternion_to_RigidTransform_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class quaternion_to_float4x4
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public quaternion* q;
@@ -476,14 +488,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * 10000, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         q[i] = quaternion.identity;
                     }
 
-                    f4x4 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * 10000, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f4x4 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f4x4[i] = float4x4.identity;
                     }
@@ -499,7 +511,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.q[i] = new quaternion(args.f4x4[i]);
                 }
@@ -557,6 +569,8 @@ public void quaternion_to_float4x4_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4x4_to_quaternion
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public quaternion* q;
@@ -565,20 +579,20 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * 10000, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         q[i] = quaternion.identity;
                     }
 
-                    f4x4 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * 10000, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f4x4 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f4x4[i] = float4x4.identity;
                     }
 
-                    f3 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f3 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f3[i] = new float3();
                     }
@@ -595,7 +609,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.f4x4[i] = new float4x4(args.q[i], args.f3[i]);
                 }
@@ -653,6 +667,8 @@ public void float4x4_to_quaternion_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4_to_uint4
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float4* f4;
@@ -660,14 +676,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    f4 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 10000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f4 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f4[i] = new float4(1.0f, 2.0f, 3.0f, 4.0f);
                     }
 
-                    u4 = (uint4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint4>() * 10000, UnsafeUtility.AlignOf<uint4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    u4 = (uint4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint4>() * iterations, UnsafeUtility.AlignOf<uint4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         u4[i] = new uint4(100, 101, 102, 103);
                     }
@@ -683,7 +699,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.u4[i] = new uint4(args.f4[i]);
                 }
@@ -741,6 +757,8 @@ public void float4_to_uint4_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class uint4_to_float4
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float4* f4;
@@ -748,14 +766,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    f4 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 10000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f4 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f4[i] = new float4(1.0f, 2.0f, 3.0f, 4.0f);
                     }
 
-                    u4 = (uint4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint4>() * 10000, UnsafeUtility.AlignOf<uint4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    u4 = (uint4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint4>() * iterations, UnsafeUtility.AlignOf<uint4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         u4[i] = new uint4(100, 101, 102, 103);
                     }
@@ -771,7 +789,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.f4[i] = new float4(args.u4[i]);
                 }
diff --git a/src/Unity.Mathematics.PerformanceTests/TestFastInverse.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestFastInverse.gen.cs
index b133ff85..62f950f0 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestFastInverse.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestFastInverse.gen.cs
@@ -21,14 +21,16 @@ partial class TestFastInverse
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4x4_fastinverse
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float4x4* m1;
 
                 public void Init()
                 {
-                    m1 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * 10000, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m1 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m1[i] = float4x4.identity;
                     }
@@ -43,7 +45,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m1[i] = math.fastinverse(args.m1[i]);
                 }
@@ -101,14 +103,16 @@ public void float4x4_fastinverse_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class double4x4_fastinverse
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public double4x4* m1;
 
                 public void Init()
                 {
-                    m1 = (double4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4x4>() * 10000, UnsafeUtility.AlignOf<double4x4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m1 = (double4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4x4>() * iterations, UnsafeUtility.AlignOf<double4x4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m1[i] = double4x4.identity;
                     }
@@ -123,7 +127,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m1[i] = math.fastinverse(args.m1[i]);
                 }
diff --git a/src/Unity.Mathematics.PerformanceTests/TestHash.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestHash.gen.cs
index b26397f9..320bda9f 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestHash.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestHash.gen.cs
@@ -21,6 +21,8 @@ partial class TestHash
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float2_hash
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public float2* v;
@@ -28,14 +30,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 100000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float2(1.0f);
                     }
 
-                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * 100000, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * iterations, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         hash[i] = 0;
                     }
@@ -51,7 +53,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.hash[i] = math.hash(args.v[i]);
                 }
@@ -109,6 +111,8 @@ public void float2_hash_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float3_hash
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public float3* v;
@@ -116,14 +120,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 100000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float3(1.0f);
                     }
 
-                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * 100000, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * iterations, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         hash[i] = 0;
                     }
@@ -139,7 +143,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.hash[i] = math.hash(args.v[i]);
                 }
@@ -197,6 +201,8 @@ public void float3_hash_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4_hash
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public float4* v;
@@ -204,14 +210,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 100000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float4(1.0f);
                     }
 
-                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * 100000, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * iterations, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         hash[i] = 0;
                     }
@@ -227,7 +233,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.hash[i] = math.hash(args.v[i]);
                 }
@@ -285,6 +291,8 @@ public void float4_hash_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class double2_hash
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public double2* v;
@@ -292,14 +300,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (double2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2>() * 100000, UnsafeUtility.AlignOf<double2>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v = (double2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2>() * iterations, UnsafeUtility.AlignOf<double2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new double2(1.0f);
                     }
 
-                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * 100000, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * iterations, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         hash[i] = 0;
                     }
@@ -315,7 +323,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.hash[i] = math.hash(args.v[i]);
                 }
@@ -373,6 +381,8 @@ public void double2_hash_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class double3_hash
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public double3* v;
@@ -380,14 +390,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * 100000, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * iterations, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new double3(1.0f);
                     }
 
-                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * 100000, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * iterations, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         hash[i] = 0;
                     }
@@ -403,7 +413,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.hash[i] = math.hash(args.v[i]);
                 }
@@ -461,6 +471,8 @@ public void double3_hash_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class double4_hash
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public double4* v;
@@ -468,14 +480,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (double4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4>() * 100000, UnsafeUtility.AlignOf<double4>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v = (double4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4>() * iterations, UnsafeUtility.AlignOf<double4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new double4(1.0f);
                     }
 
-                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * 100000, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * iterations, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         hash[i] = 0;
                     }
@@ -491,7 +503,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.hash[i] = math.hash(args.v[i]);
                 }
@@ -549,6 +561,8 @@ public void double4_hash_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float2x2_hash
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public float2x2* v;
@@ -556,14 +570,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * 100000, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * iterations, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float2x2(1.0f);
                     }
 
-                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * 100000, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * iterations, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         hash[i] = 0;
                     }
@@ -579,7 +593,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.hash[i] = math.hash(args.v[i]);
                 }
@@ -637,6 +651,8 @@ public void float2x2_hash_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float3x3_hash
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public float3x3* v;
@@ -644,14 +660,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * 100000, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float3x3(1.0f);
                     }
 
-                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * 100000, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * iterations, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         hash[i] = 0;
                     }
@@ -667,7 +683,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.hash[i] = math.hash(args.v[i]);
                 }
@@ -725,6 +741,8 @@ public void float3x3_hash_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4x4_hash
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public float4x4* v;
@@ -732,14 +750,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * 100000, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float4x4(1.0f);
                     }
 
-                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * 100000, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    hash = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * iterations, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         hash[i] = 0;
                     }
@@ -755,7 +773,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.hash[i] = math.hash(args.v[i]);
                 }
@@ -813,6 +831,8 @@ public void float4x4_hash_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float2x2_hashwide
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public float2x2* v;
@@ -820,14 +840,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * 100000, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * iterations, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float2x2(1.0f);
                     }
 
-                    hash = (uint2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint2>() * 100000, UnsafeUtility.AlignOf<uint2>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    hash = (uint2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint2>() * iterations, UnsafeUtility.AlignOf<uint2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         hash[i] = 0;
                     }
@@ -843,7 +863,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.hash[i] = math.hashwide(args.v[i]);
                 }
@@ -901,6 +921,8 @@ public void float2x2_hashwide_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float3x3_hashwide
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public float3x3* v;
@@ -908,14 +930,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * 100000, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float3x3(1.0f);
                     }
 
-                    hash = (uint3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint3>() * 100000, UnsafeUtility.AlignOf<uint3>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    hash = (uint3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint3>() * iterations, UnsafeUtility.AlignOf<uint3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         hash[i] = 0;
                     }
@@ -931,7 +953,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.hash[i] = math.hashwide(args.v[i]);
                 }
@@ -989,6 +1011,8 @@ public void float3x3_hashwide_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4x4_hashwide
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public float4x4* v;
@@ -996,14 +1020,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * 100000, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float4x4(1.0f);
                     }
 
-                    hash = (uint4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint4>() * 100000, UnsafeUtility.AlignOf<uint4>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    hash = (uint4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint4>() * iterations, UnsafeUtility.AlignOf<uint4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         hash[i] = 0;
                     }
@@ -1019,7 +1043,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.hash[i] = math.hashwide(args.v[i]);
                 }
@@ -1077,6 +1101,8 @@ public void float4x4_hashwide_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float2_hashwide
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public float2* v;
@@ -1084,14 +1110,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 100000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float2(1.0f);
                     }
 
-                    hash = (uint2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint2>() * 100000, UnsafeUtility.AlignOf<uint2>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    hash = (uint2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint2>() * iterations, UnsafeUtility.AlignOf<uint2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         hash[i] = new uint2();
                     }
@@ -1107,7 +1133,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.hash[i] = math.hashwide(args.v[i]);
                 }
diff --git a/src/Unity.Mathematics.PerformanceTests/TestInverse.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestInverse.gen.cs
index 5450d48c..438bfb75 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestInverse.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestInverse.gen.cs
@@ -21,14 +21,16 @@ partial class TestInverse
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4x4_inverse
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float4x4* m1;
 
                 public void Init()
                 {
-                    m1 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * 10000, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m1 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m1[i] = float4x4.identity;
                     }
@@ -43,7 +45,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m1[i] = math.inverse(args.m1[i]);
                 }
@@ -101,14 +103,16 @@ public void float4x4_inverse_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float3x3_inverse
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3x3* m1;
 
                 public void Init()
                 {
-                    m1 = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * 10000, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m1 = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m1[i] = float3x3.identity;
                     }
@@ -123,7 +127,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m1[i] = math.inverse(args.m1[i]);
                 }
@@ -181,14 +185,16 @@ public void float3x3_inverse_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float2x2_inverse
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float2x2* m1;
 
                 public void Init()
                 {
-                    m1 = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * 10000, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m1 = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * iterations, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m1[i] = float2x2.identity;
                     }
@@ -203,7 +209,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m1[i] = math.inverse(args.m1[i]);
                 }
@@ -261,14 +267,16 @@ public void float2x2_inverse_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class double4x4_inverse
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public double4x4* m1;
 
                 public void Init()
                 {
-                    m1 = (double4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4x4>() * 10000, UnsafeUtility.AlignOf<double4x4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m1 = (double4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4x4>() * iterations, UnsafeUtility.AlignOf<double4x4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m1[i] = double4x4.identity;
                     }
@@ -283,7 +291,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m1[i] = math.inverse(args.m1[i]);
                 }
@@ -341,14 +349,16 @@ public void double4x4_inverse_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class double3x3_inverse
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public double3x3* m1;
 
                 public void Init()
                 {
-                    m1 = (double3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3x3>() * 10000, UnsafeUtility.AlignOf<double3x3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m1 = (double3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3x3>() * iterations, UnsafeUtility.AlignOf<double3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m1[i] = double3x3.identity;
                     }
@@ -363,7 +373,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m1[i] = math.inverse(args.m1[i]);
                 }
@@ -421,14 +431,16 @@ public void double3x3_inverse_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class double2x2_inverse
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public double2x2* m1;
 
                 public void Init()
                 {
-                    m1 = (double2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2x2>() * 10000, UnsafeUtility.AlignOf<double2x2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m1 = (double2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2x2>() * iterations, UnsafeUtility.AlignOf<double2x2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m1[i] = double2x2.identity;
                     }
@@ -443,7 +455,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m1[i] = math.inverse(args.m1[i]);
                 }
@@ -501,14 +513,16 @@ public void double2x2_inverse_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class quaternion_inverse
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public quaternion* q;
 
                 public void Init()
                 {
-                    q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * 10000, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         q[i] = quaternion.identity;
                     }
@@ -523,7 +537,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.q[i] = math.inverse(args.q[i]);
                 }
diff --git a/src/Unity.Mathematics.PerformanceTests/TestMath.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestMath.gen.cs
index d2efa23f..01376555 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestMath.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestMath.gen.cs
@@ -21,6 +21,8 @@ partial class TestMath
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class orthonormal_basis_float
         {
+            public const int iterations = 1000000;
+
             public struct Arguments : IDisposable
             {
                 public Random* rng;
@@ -30,26 +32,26 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * 1000000, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < 1000000; ++i)
+                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         rng[i] = new Random(1234u);
                     }
 
-                    v1 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 1000000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 1000000; ++i)
+                    v1 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v1[i] = rng[0].NextFloat3Direction();
                     }
 
-                    v2 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 1000000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 1000000; ++i)
+                    v2 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v2[i] = new float3();
                     }
 
-                    v3 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 1000000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 1000000; ++i)
+                    v3 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v3[i] = new float3();
                     }
@@ -67,7 +69,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 1000000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     math.orthonormal_basis(args.v1[i], out args.v2[i], out args.v3[i]);
                 }
@@ -125,6 +127,8 @@ public void orthonormal_basis_float_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class orthonormal_basis_double
         {
+            public const int iterations = 1000000;
+
             public struct Arguments : IDisposable
             {
                 public Random* rng;
@@ -134,26 +138,26 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * 1000000, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < 1000000; ++i)
+                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         rng[i] = new Random(1234u);
                     }
 
-                    v1 = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * 1000000, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
-                    for (int i = 0; i < 1000000; ++i)
+                    v1 = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * iterations, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v1[i] = rng[0].NextDouble3Direction();
                     }
 
-                    v2 = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * 1000000, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
-                    for (int i = 0; i < 1000000; ++i)
+                    v2 = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * iterations, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v2[i] = new double();
                     }
 
-                    v3 = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * 1000000, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
-                    for (int i = 0; i < 1000000; ++i)
+                    v3 = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * iterations, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v3[i] = new double();
                     }
@@ -171,7 +175,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 1000000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     math.orthonormal_basis(args.v1[i], out args.v2[i], out args.v3[i]);
                 }
diff --git a/src/Unity.Mathematics.PerformanceTests/TestMinMaxAABB.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestMinMaxAABB.gen.cs
index 41590ed8..b964fec4 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestMinMaxAABB.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestMinMaxAABB.gen.cs
@@ -21,14 +21,16 @@ partial class TestMinMaxAABB
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class Transform_float4x4
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public Geometry.MinMaxAABB* a;
 
                 public void Init()
                 {
-                    a = (Geometry.MinMaxAABB*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Geometry.MinMaxAABB>() * 100000, UnsafeUtility.AlignOf<Geometry.MinMaxAABB>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    a = (Geometry.MinMaxAABB*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Geometry.MinMaxAABB>() * iterations, UnsafeUtility.AlignOf<Geometry.MinMaxAABB>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         a[i] = new Geometry.MinMaxAABB();
                     }
@@ -43,7 +45,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.a[i] = Geometry.Math.Transform(float4x4.identity, args.a[i]);
                 }
@@ -101,14 +103,16 @@ public void Transform_float4x4_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class Transform_float3x3
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public Geometry.MinMaxAABB* a;
 
                 public void Init()
                 {
-                    a = (Geometry.MinMaxAABB*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Geometry.MinMaxAABB>() * 100000, UnsafeUtility.AlignOf<Geometry.MinMaxAABB>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    a = (Geometry.MinMaxAABB*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Geometry.MinMaxAABB>() * iterations, UnsafeUtility.AlignOf<Geometry.MinMaxAABB>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         a[i] = new Geometry.MinMaxAABB();
                     }
@@ -123,7 +127,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.a[i] = Geometry.Math.Transform(float3x3.identity, args.a[i]);
                 }
diff --git a/src/Unity.Mathematics.PerformanceTests/TestMul.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestMul.gen.cs
index 85bf5525..06c29893 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestMul.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestMul.gen.cs
@@ -21,6 +21,8 @@ partial class TestMul
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4x4_float4x4
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float4x4* m1;
@@ -28,14 +30,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    m1 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * 10000, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m1 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m1[i] = float4x4.identity;
                     }
 
-                    m2 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * 10000, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m2 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m2[i] = float4x4.identity;
                     }
@@ -51,7 +53,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m1[i] = math.mul(args.m1[i], args.m2[i]);
                 }
@@ -109,6 +111,8 @@ public void float4x4_float4x4_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4x4_float4
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float4x4* m1;
@@ -116,14 +120,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    m1 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * 10000, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m1 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m1[i] = float4x4.identity;
                     }
 
-                    m2 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 10000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m2 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m2[i] = new float4(1.0f, 0.0f, 0.0f, 1.0f);
                     }
@@ -139,7 +143,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m2[i] = math.mul(args.m1[i], args.m2[i]);
                 }
@@ -197,6 +201,8 @@ public void float4x4_float4_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class quaternion_quaternion
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public quaternion* q1;
@@ -204,14 +210,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    q1 = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * 10000, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    q1 = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         q1[i] = quaternion.identity;
                     }
 
-                    q2 = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * 10000, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    q2 = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         q2[i] = quaternion.identity;
                     }
@@ -227,7 +233,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.q2[i] = math.mul(args.q1[i], args.q2[i]);
                 }
@@ -285,6 +291,8 @@ public void quaternion_quaternion_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float3x3_float3x3
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3x3* m1;
@@ -292,14 +300,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    m1 = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * 10000, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m1 = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m1[i] = float3x3.identity;
                     }
 
-                    m2 = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * 10000, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m2 = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m2[i] = float3x3.identity;
                     }
@@ -315,7 +323,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m2[i] = math.mul(args.m1[i], args.m2[i]);
                 }
@@ -373,6 +381,8 @@ public void float3x3_float3x3_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float2x2_float2x2
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float2x2* m1;
@@ -380,14 +390,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    m1 = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * 10000, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m1 = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * iterations, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m1[i] = float2x2.identity;
                     }
 
-                    m2 = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * 10000, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m2 = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * iterations, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m2[i] = float2x2.identity;
                     }
@@ -403,7 +413,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m2[i] = math.mul(args.m1[i], args.m2[i]);
                 }
@@ -461,6 +471,8 @@ public void float2x2_float2x2_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float3x3_float3
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3x3* m1;
@@ -468,14 +480,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    m1 = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * 10000, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m1 = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m1[i] = float3x3.identity;
                     }
 
-                    m2 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m2 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m2[i] = new float3(1.0f, 0.0f, 0.0f);
                     }
@@ -491,7 +503,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m2[i] = math.mul(args.m1[i], args.m2[i]);
                 }
@@ -549,6 +561,8 @@ public void float3x3_float3_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float2x2_float2
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float2x2* m1;
@@ -556,14 +570,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    m1 = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * 10000, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m1 = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * iterations, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m1[i] = float2x2.identity;
                     }
 
-                    m2 = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 10000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m2 = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m2[i] = new float2(1.0f, 0.0f);
                     }
@@ -579,7 +593,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m2[i] = math.mul(args.m1[i], args.m2[i]);
                 }
diff --git a/src/Unity.Mathematics.PerformanceTests/TestNoise.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestNoise.gen.cs
index c9d18d8d..988d06a6 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestNoise.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestNoise.gen.cs
@@ -21,14 +21,16 @@ partial class TestNoise
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class snoise2D
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float2* v;
 
                 public void Init()
                 {
-                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 10000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float2();
                     }
@@ -43,7 +45,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i].x = noise.snoise(args.v[i]);
                 }
@@ -101,14 +103,16 @@ public void snoise2D_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class snoise3D
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3* v;
 
                 public void Init()
                 {
-                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float3();
                     }
@@ -123,7 +127,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i].x = noise.snoise(args.v[i]);
                 }
@@ -181,14 +185,16 @@ public void snoise3D_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class snoise4D
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float4* v;
 
                 public void Init()
                 {
-                    v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 10000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float4();
                     }
@@ -203,7 +209,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i].x = noise.snoise(args.v[i]);
                 }
@@ -261,6 +267,8 @@ public void snoise4D_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class snoise3Dgrad
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3* v;
@@ -268,14 +276,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float3();
                     }
 
-                    gradient = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    gradient = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         gradient[i] = new float3();
                     }
@@ -291,7 +299,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i].x = noise.snoise(args.v[i], out args.gradient[i]);
                 }
@@ -349,14 +357,16 @@ public void snoise3Dgrad_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class cnoise2D
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float2* v;
 
                 public void Init()
                 {
-                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 10000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float2();
                     }
@@ -371,7 +381,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i].x = noise.cnoise(args.v[i]);
                 }
@@ -429,14 +439,16 @@ public void cnoise2D_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class cnoise3D
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3* v;
 
                 public void Init()
                 {
-                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float3();
                     }
@@ -451,7 +463,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i].x = noise.cnoise(args.v[i]);
                 }
@@ -509,14 +521,16 @@ public void cnoise3D_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class cnoise4D
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float4* v;
 
                 public void Init()
                 {
-                    v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 10000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float4();
                     }
@@ -531,7 +545,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i].x = noise.cnoise(args.v[i]);
                 }
@@ -589,14 +603,16 @@ public void cnoise4D_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class pnoise2D
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float2* v;
 
                 public void Init()
                 {
-                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 10000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float2();
                     }
@@ -611,7 +627,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i].x = noise.pnoise(args.v[i], args.v[i]);
                 }
@@ -669,14 +685,16 @@ public void pnoise2D_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class pnoise3D
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3* v;
 
                 public void Init()
                 {
-                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float3();
                     }
@@ -691,7 +709,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i].x = noise.pnoise(args.v[i], args.v[i]);
                 }
@@ -749,14 +767,16 @@ public void pnoise3D_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class pnoise4D
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float4* v;
 
                 public void Init()
                 {
-                    v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 10000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float4();
                     }
@@ -771,7 +791,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i].x = noise.pnoise(args.v[i], args.v[i]);
                 }
@@ -829,14 +849,16 @@ public void pnoise4D_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class cellular2D
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float2* v;
 
                 public void Init()
                 {
-                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 10000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float2();
                     }
@@ -851,7 +873,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i] = noise.cellular(args.v[i]);
                 }
@@ -909,14 +931,16 @@ public void cellular2D_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class cellular3D
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3* v;
 
                 public void Init()
                 {
-                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float3();
                     }
@@ -931,7 +955,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i].xy = noise.cellular(args.v[i]);
                 }
@@ -989,14 +1013,16 @@ public void cellular3D_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class cellular2x2
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float2* v;
 
                 public void Init()
                 {
-                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 10000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float2();
                     }
@@ -1011,7 +1037,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i] = noise.cellular2x2(args.v[i]);
                 }
@@ -1069,14 +1095,16 @@ public void cellular2x2_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class cellular2x2x2
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3* v;
 
                 public void Init()
                 {
-                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float3();
                     }
@@ -1091,7 +1119,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i].xy = noise.cellular2x2x2(args.v[i]);
                 }
@@ -1149,14 +1177,16 @@ public void cellular2x2x2_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class psrdnoise
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float2* v;
 
                 public void Init()
                 {
-                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 10000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float2();
                     }
@@ -1171,7 +1201,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i] = noise.psrdnoise(args.v[i], args.v[i], args.v[i].y).xy;
                 }
@@ -1229,14 +1259,16 @@ public void psrdnoise_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class psrnoise
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float2* v;
 
                 public void Init()
                 {
-                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 10000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float2();
                     }
@@ -1251,7 +1283,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i].x = noise.psrnoise(args.v[i], args.v[i], args.v[i].y);
                 }
@@ -1309,14 +1341,16 @@ public void psrnoise_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class srdnoise
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float2* v;
 
                 public void Init()
                 {
-                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 10000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float2();
                     }
@@ -1331,7 +1365,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i] = noise.srdnoise(args.v[i], args.v[i].y).xy;
                 }
@@ -1389,14 +1423,16 @@ public void srdnoise_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class srnoise
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float2* v;
 
                 public void Init()
                 {
-                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 10000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float2();
                     }
@@ -1411,7 +1447,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i].x = noise.srnoise(args.v[i], args.v[i].y);
                 }
diff --git a/src/Unity.Mathematics.PerformanceTests/TestNormalize.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestNormalize.gen.cs
index 869b5f14..b2915796 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestNormalize.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestNormalize.gen.cs
@@ -21,14 +21,16 @@ partial class TestNormalize
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4_normalize
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float4* v;
 
                 public void Init()
                 {
-                    v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 10000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float4(1.0f);
                     }
@@ -43,7 +45,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i] = math.normalize(args.v[i]);
                 }
@@ -101,14 +103,16 @@ public void float4_normalize_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float3_normalize
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3* v;
 
                 public void Init()
                 {
-                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float3(1.0f);
                     }
@@ -123,7 +127,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i] = math.normalize(args.v[i]);
                 }
@@ -181,14 +185,16 @@ public void float3_normalize_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float2_normalize
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float2* v;
 
                 public void Init()
                 {
-                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 10000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float2(1.0f);
                     }
@@ -203,7 +209,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i] = math.normalize(args.v[i]);
                 }
@@ -261,14 +267,16 @@ public void float2_normalize_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class double4_normalize
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public double4* v;
 
                 public void Init()
                 {
-                    v = (double4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4>() * 10000, UnsafeUtility.AlignOf<double4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (double4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4>() * iterations, UnsafeUtility.AlignOf<double4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new double4(1.0f);
                     }
@@ -283,7 +291,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i] = math.normalize(args.v[i]);
                 }
@@ -341,14 +349,16 @@ public void double4_normalize_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class double3_normalize
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public double3* v;
 
                 public void Init()
                 {
-                    v = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * 10000, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * iterations, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new double3(1.0f);
                     }
@@ -363,7 +373,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i] = math.normalize(args.v[i]);
                 }
@@ -421,14 +431,16 @@ public void double3_normalize_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class double2_normalize
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public double2* v;
 
                 public void Init()
                 {
-                    v = (double2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2>() * 10000, UnsafeUtility.AlignOf<double2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (double2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2>() * iterations, UnsafeUtility.AlignOf<double2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new double2(1.0f);
                     }
@@ -443,7 +455,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i] = math.normalize(args.v[i]);
                 }
@@ -501,14 +513,16 @@ public void double2_normalize_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4_normalizesafe
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float4* v;
 
                 public void Init()
                 {
-                    v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 10000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float4(1.0f);
                     }
@@ -523,7 +537,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i] = math.normalizesafe(args.v[i]);
                 }
@@ -581,14 +595,16 @@ public void float4_normalizesafe_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float3_normalizesafe
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3* v;
 
                 public void Init()
                 {
-                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float3(1.0f);
                     }
@@ -603,7 +619,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i] = math.normalizesafe(args.v[i]);
                 }
@@ -661,14 +677,16 @@ public void float3_normalizesafe_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float2_normalizesafe
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float2* v;
 
                 public void Init()
                 {
-                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 10000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float2(1.0f);
                     }
@@ -683,7 +701,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i] = math.normalizesafe(args.v[i]);
                 }
@@ -741,14 +759,16 @@ public void float2_normalizesafe_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class double4_normalizesafe
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public double4* v;
 
                 public void Init()
                 {
-                    v = (double4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4>() * 10000, UnsafeUtility.AlignOf<double4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (double4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4>() * iterations, UnsafeUtility.AlignOf<double4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new double4(1.0f);
                     }
@@ -763,7 +783,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i] = math.normalizesafe(args.v[i]);
                 }
@@ -821,14 +841,16 @@ public void double4_normalizesafe_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class double3_normalizesafe
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public double3* v;
 
                 public void Init()
                 {
-                    v = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * 10000, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * iterations, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new double3(1.0f);
                     }
@@ -843,7 +865,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i] = math.normalizesafe(args.v[i]);
                 }
@@ -901,14 +923,16 @@ public void double3_normalizesafe_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class double2_normalizesafe
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public double2* v;
 
                 public void Init()
                 {
-                    v = (double2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2>() * 10000, UnsafeUtility.AlignOf<double2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (double2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2>() * iterations, UnsafeUtility.AlignOf<double2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new double2(1.0f);
                     }
@@ -923,7 +947,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.v[i] = math.normalizesafe(args.v[i]);
                 }
diff --git a/src/Unity.Mathematics.PerformanceTests/TestPlane.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestPlane.gen.cs
index ae1818bc..cb29c3b2 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestPlane.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestPlane.gen.cs
@@ -21,14 +21,16 @@ partial class TestPlane
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class Normalize_Plane
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public Plane* p;
 
                 public void Init()
                 {
-                    p = (Plane*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Plane>() * 10000, UnsafeUtility.AlignOf<Plane>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    p = (Plane*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Plane>() * iterations, UnsafeUtility.AlignOf<Plane>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         p[i] = new Plane { NormalAndDistance = new float4(1.0f) };
                     }
@@ -43,7 +45,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.p[i] = Plane.Normalize(args.p[i]);
                 }
diff --git a/src/Unity.Mathematics.PerformanceTests/TestRandom.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestRandom.gen.cs
index 51055cc9..ee29e432 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestRandom.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestRandom.gen.cs
@@ -21,6 +21,8 @@ partial class TestRandom
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class Random_NextUint
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public Random* rng;
@@ -28,14 +30,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * 10000, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         rng[i] = new Unity.Mathematics.Random(1);
                     }
 
-                    u = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * 10000, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    u = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * iterations, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         u[i] = 0;
                     }
@@ -51,7 +53,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.u[i] = args.rng[i].NextUInt();
                 }
@@ -109,6 +111,8 @@ public void Random_NextUint_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class Random_NextUint2
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public Random* rng;
@@ -116,14 +120,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * 10000, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         rng[i] = new Unity.Mathematics.Random(1);
                     }
 
-                    u = (uint2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint2>() * 10000, UnsafeUtility.AlignOf<uint2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    u = (uint2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint2>() * iterations, UnsafeUtility.AlignOf<uint2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         u[i] = 0;
                     }
@@ -139,7 +143,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.u[i] = args.rng[i].NextUInt2();
                 }
@@ -197,6 +201,8 @@ public void Random_NextUint2_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class Random_NextUint3
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public Random* rng;
@@ -204,14 +210,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * 10000, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         rng[i] = new Unity.Mathematics.Random(1);
                     }
 
-                    u = (uint3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint3>() * 10000, UnsafeUtility.AlignOf<uint3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    u = (uint3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint3>() * iterations, UnsafeUtility.AlignOf<uint3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         u[i] = 0;
                     }
@@ -227,7 +233,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.u[i] = args.rng[i].NextUInt3();
                 }
@@ -285,6 +291,8 @@ public void Random_NextUint3_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class Random_NextUint4
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public Random* rng;
@@ -292,14 +300,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * 10000, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         rng[i] = new Unity.Mathematics.Random(1);
                     }
 
-                    u = (uint4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint4>() * 10000, UnsafeUtility.AlignOf<uint4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    u = (uint4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint4>() * iterations, UnsafeUtility.AlignOf<uint4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         u[i] = 0;
                     }
@@ -315,7 +323,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.u[i] = args.rng[i].NextUInt4();
                 }
@@ -373,6 +381,8 @@ public void Random_NextUint4_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class Random_NextFloat
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public Random* rng;
@@ -380,14 +390,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * 10000, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         rng[i] = new Unity.Mathematics.Random(1);
                     }
 
-                    f = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * 10000, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * iterations, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f[i] = 0.0f;
                     }
@@ -403,7 +413,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.f[i] = args.rng[i].NextFloat();
                 }
@@ -461,6 +471,8 @@ public void Random_NextFloat_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class Random_NextFloat2
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public Random* rng;
@@ -468,14 +480,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * 10000, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         rng[i] = new Unity.Mathematics.Random(1);
                     }
 
-                    f = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 10000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f[i] = new float2(0.0f);
                     }
@@ -491,7 +503,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.f[i] = args.rng[i].NextFloat2();
                 }
@@ -549,6 +561,8 @@ public void Random_NextFloat2_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class Random_NextFloat3
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public Random* rng;
@@ -556,14 +570,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * 10000, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         rng[i] = new Unity.Mathematics.Random(1);
                     }
 
-                    f = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f[i] = new float3(0.0f);
                     }
@@ -579,7 +593,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.f[i] = args.rng[i].NextFloat3();
                 }
@@ -637,6 +651,8 @@ public void Random_NextFloat3_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class Random_NextFloat4
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public Random* rng;
@@ -644,14 +660,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * 10000, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         rng[i] = new Unity.Mathematics.Random(1);
                     }
 
-                    f = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 10000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f[i] = new float4(0.0f);
                     }
@@ -667,7 +683,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.f[i] = args.rng[i].NextFloat4();
                 }
@@ -725,6 +741,8 @@ public void Random_NextFloat4_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class Random_NextDouble
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public Random* rng;
@@ -732,14 +750,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * 10000, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         rng[i] = new Unity.Mathematics.Random(1);
                     }
 
-                    f = (double*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double>() * 10000, UnsafeUtility.AlignOf<double>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f = (double*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double>() * iterations, UnsafeUtility.AlignOf<double>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f[i] = 0.0;
                     }
@@ -755,7 +773,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.f[i] = args.rng[i].NextDouble();
                 }
@@ -813,6 +831,8 @@ public void Random_NextDouble_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class Random_NextDouble2
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public Random* rng;
@@ -820,14 +840,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * 10000, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         rng[i] = new Unity.Mathematics.Random(1);
                     }
 
-                    f = (double2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2>() * 10000, UnsafeUtility.AlignOf<double2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f = (double2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2>() * iterations, UnsafeUtility.AlignOf<double2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f[i] = new double2(0.0);
                     }
@@ -843,7 +863,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.f[i] = args.rng[i].NextDouble2();
                 }
@@ -901,6 +921,8 @@ public void Random_NextDouble2_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class Random_NextDouble3
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public Random* rng;
@@ -908,14 +930,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * 10000, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         rng[i] = new Unity.Mathematics.Random(1);
                     }
 
-                    f = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * 10000, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * iterations, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f[i] = new double3(0.0);
                     }
@@ -931,7 +953,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.f[i] = args.rng[i].NextDouble3();
                 }
@@ -989,6 +1011,8 @@ public void Random_NextDouble3_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class Random_NextDouble4
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public Random* rng;
@@ -996,14 +1020,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * 10000, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         rng[i] = new Unity.Mathematics.Random(1);
                     }
 
-                    f = (double4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4>() * 10000, UnsafeUtility.AlignOf<double4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    f = (double4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4>() * iterations, UnsafeUtility.AlignOf<double4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         f[i] = new double4(0.0);
                     }
@@ -1019,7 +1043,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.f[i] = args.rng[i].NextDouble4();
                 }
diff --git a/src/Unity.Mathematics.PerformanceTests/TestRotation.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestRotation.gen.cs
index 27fbc1dd..e0324fce 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestRotation.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestRotation.gen.cs
@@ -21,6 +21,8 @@ partial class TestRotation
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4x4_EulerXYZ
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3* v;
@@ -28,14 +30,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float3(1.0f);
                     }
 
-                    m = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * 10000, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m[i] = float4x4.identity;
                     }
@@ -51,7 +53,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m[i] = float4x4.EulerXYZ(args.v[i]);
                 }
@@ -109,6 +111,8 @@ public void float4x4_EulerXYZ_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float3x3_EulerXYZ
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3* v;
@@ -116,14 +120,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = new float3(1.0f);
                     }
 
-                    m = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * 10000, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m[i] = float3x3.identity;
                     }
@@ -139,7 +143,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m[i] = float3x3.EulerXYZ(args.v[i]);
                 }
@@ -197,6 +201,8 @@ public void float3x3_EulerXYZ_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4x4_AxisAngle
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3* v;
@@ -205,20 +211,20 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = math.normalize(new float3(1.0f));
                     }
 
-                    m = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * 10000, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m[i] = float4x4.identity;
                     }
 
-                    angle = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * 10000, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    angle = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * iterations, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         angle[i] = 1.0f;
                     }
@@ -235,7 +241,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m[i] = float4x4.AxisAngle(args.v[i], args.angle[i]);
                 }
@@ -293,6 +299,8 @@ public void float4x4_AxisAngle_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float3x3_AxisAngle
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3* v;
@@ -301,20 +309,20 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v[i] = math.normalize(new float3(1.0f));
                     }
 
-                    m = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * 10000, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m[i] = float3x3.identity;
                     }
 
-                    angle = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * 10000, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    angle = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * iterations, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         angle[i] = 1.0f;
                     }
@@ -331,7 +339,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m[i] = float3x3.AxisAngle(args.v[i], args.angle[i]);
                 }
@@ -389,6 +397,8 @@ public void float3x3_AxisAngle_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float3x3_LookRotation
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3* forward;
@@ -397,20 +407,20 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    forward = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    forward = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         forward[i] = math.normalize(new float3(1.0f));
                     }
 
-                    up = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    up = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         up[i] = math.normalize(new float3(0.0f, 1.0f, 0.0f));
                     }
 
-                    m = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * 10000, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m[i] = float3x3.identity;
                     }
@@ -427,7 +437,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m[i] = float3x3.LookRotation(args.forward[i], args.up[i]);
                 }
@@ -485,6 +495,8 @@ public void float3x3_LookRotation_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float3x3_LookRotationSafe
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3* forward;
@@ -493,20 +505,20 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    forward = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    forward = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         forward[i] = math.normalize(new float3(1.0f));
                     }
 
-                    up = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    up = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         up[i] = math.normalize(new float3(0.0f, 1.0f, 0.0f));
                     }
 
-                    m = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * 10000, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m[i] = float3x3.identity;
                     }
@@ -523,7 +535,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m[i] = float3x3.LookRotationSafe(args.forward[i], args.up[i]);
                 }
@@ -581,6 +593,8 @@ public void float3x3_LookRotationSafe_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4x4_LookAt
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3* eye;
@@ -590,26 +604,26 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    eye = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    eye = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         eye[i] = math.normalize(new float3(1.0f));
                     }
 
-                    target = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    target = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         target[i] = math.normalize(new float3(0.0f, 1.0f, 0.0f));
                     }
 
-                    up = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    up = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         up[i] = math.normalize(new float3(-5.0f, 2.0f, 3.0f));
                     }
 
-                    m = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * 10000, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m[i] = float4x4.identity;
                     }
@@ -627,7 +641,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m[i] = float4x4.LookAt(args.eye[i], args.target[i], args.up[i]);
                 }
diff --git a/src/Unity.Mathematics.PerformanceTests/TestShuffle.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestShuffle.gen.cs
index a4d37840..2d0c0a55 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestShuffle.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestShuffle.gen.cs
@@ -21,6 +21,8 @@ partial class TestShuffle
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float2_shuffle
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public float2* v1;
@@ -29,20 +31,20 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v1 = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 100000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v1 = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v1[i] = new float2(1.0f);
                     }
 
-                    v2 = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 100000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v2 = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v2[i] = new float2(2.0f);
                     }
 
-                    result = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 100000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    result = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         result[i] = new float2(1.0f);
                     }
@@ -59,7 +61,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.result[i] = math.shuffle(args.v1[i], args.v2[i], math.ShuffleComponent.RightX, math.ShuffleComponent.LeftY);
                 }
@@ -117,6 +119,8 @@ public void float2_shuffle_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float3_shuffle
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public float3* v1;
@@ -125,20 +129,20 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v1 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 100000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v1 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v1[i] = new float3(1.0f);
                     }
 
-                    v2 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 100000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v2 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v2[i] = new float3(2.0f);
                     }
 
-                    result = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 100000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    result = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         result[i] = new float3(1.0f);
                     }
@@ -155,7 +159,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.result[i] = math.shuffle(args.v1[i], args.v2[i], math.ShuffleComponent.RightX, math.ShuffleComponent.LeftZ, math.ShuffleComponent.LeftX);
                 }
@@ -213,6 +217,8 @@ public void float3_shuffle_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4_shuffle
         {
+            public const int iterations = 100000;
+
             public struct Arguments : IDisposable
             {
                 public float4* v1;
@@ -221,20 +227,20 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    v1 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 100000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v1 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v1[i] = new float4(1.0f);
                     }
 
-                    v2 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 100000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    v2 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         v2[i] = new float4(2.0f);
                     }
 
-                    result = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 100000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 100000; ++i)
+                    result = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         result[i] = new float4(1.0f);
                     }
@@ -251,7 +257,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 100000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.result[i] = math.shuffle(args.v1[i], args.v2[i], math.ShuffleComponent.RightX, math.ShuffleComponent.LeftZ, math.ShuffleComponent.LeftX, math.ShuffleComponent.RightY);
                 }
diff --git a/src/Unity.Mathematics.PerformanceTests/TestTranspose.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestTranspose.gen.cs
index 67625c77..ff0d0c8a 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestTranspose.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestTranspose.gen.cs
@@ -21,14 +21,16 @@ partial class TestTranspose
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class transpose_float4x4
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float4x4* m;
 
                 public void Init()
                 {
-                    m = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * 10000, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m[i] = float4x4.identity;
                     }
@@ -43,7 +45,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m[i] = math.transpose(args.m[i]);
                 }
@@ -101,14 +103,16 @@ public void transpose_float4x4_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class transpose_float3x3
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3x3* m;
 
                 public void Init()
                 {
-                    m = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * 10000, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m[i] = float3x3.identity;
                     }
@@ -123,7 +127,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m[i] = math.transpose(args.m[i]);
                 }
@@ -181,14 +185,16 @@ public void transpose_float3x3_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class transpose_float2x2
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float2x2* m;
 
                 public void Init()
                 {
-                    m = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * 10000, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * iterations, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m[i] = float2x2.identity;
                     }
@@ -203,7 +209,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m[i] = math.transpose(args.m[i]);
                 }
@@ -261,14 +267,16 @@ public void transpose_float2x2_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class transpose_double4x4
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public double4x4* m;
 
                 public void Init()
                 {
-                    m = (double4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4x4>() * 10000, UnsafeUtility.AlignOf<double4x4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m = (double4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4x4>() * iterations, UnsafeUtility.AlignOf<double4x4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m[i] = double4x4.identity;
                     }
@@ -283,7 +291,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m[i] = math.transpose(args.m[i]);
                 }
@@ -341,14 +349,16 @@ public void transpose_double4x4_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class transpose_double3x3
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public double3x3* m;
 
                 public void Init()
                 {
-                    m = (double3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3x3>() * 10000, UnsafeUtility.AlignOf<double3x3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m = (double3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3x3>() * iterations, UnsafeUtility.AlignOf<double3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m[i] = double3x3.identity;
                     }
@@ -363,7 +373,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m[i] = math.transpose(args.m[i]);
                 }
@@ -421,14 +431,16 @@ public void transpose_double3x3_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class transpose_double2x2
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public double2x2* m;
 
                 public void Init()
                 {
-                    m = (double2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2x2>() * 10000, UnsafeUtility.AlignOf<double2x2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    m = (double2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2x2>() * iterations, UnsafeUtility.AlignOf<double2x2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         m[i] = double2x2.identity;
                     }
@@ -443,7 +455,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     args.m[i] = math.transpose(args.m[i]);
                 }
diff --git a/src/Unity.Mathematics.PerformanceTests/TestTrig.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestTrig.gen.cs
index 55e88160..4f0ab126 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestTrig.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestTrig.gen.cs
@@ -21,6 +21,8 @@ partial class TestTrig
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float_sincos
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float* sin;
@@ -28,14 +30,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    sin = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * 10000, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    sin = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * iterations, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         sin[i] = 0.0f;
                     }
 
-                    cos = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * 10000, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    cos = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * iterations, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         cos[i] = 1.0f;
                     }
@@ -51,7 +53,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     math.sincos(args.sin[i], out args.sin[i], out args.cos[i]);
                 }
@@ -109,6 +111,8 @@ public void float_sincos_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float2_sincos
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float2* sin;
@@ -116,14 +120,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    sin = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 10000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    sin = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         sin[i] = new float2(0.0f);
                     }
 
-                    cos = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * 10000, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    cos = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         cos[i] = new float2(1.0f);
                     }
@@ -139,7 +143,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     math.sincos(args.sin[i], out args.sin[i], out args.cos[i]);
                 }
@@ -197,6 +201,8 @@ public void float2_sincos_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float3_sincos
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float3* sin;
@@ -204,14 +210,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    sin = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    sin = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         sin[i] = new float3(0.0f);
                     }
 
-                    cos = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * 10000, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    cos = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         cos[i] = new float3(1.0f);
                     }
@@ -227,7 +233,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     math.sincos(args.sin[i], out args.sin[i], out args.cos[i]);
                 }
@@ -285,6 +291,8 @@ public void float3_sincos_burst()
         [BurstCompile(CompileSynchronously = true)]
         public unsafe class float4_sincos
         {
+            public const int iterations = 10000;
+
             public struct Arguments : IDisposable
             {
                 public float4* sin;
@@ -292,14 +300,14 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
-                    sin = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 10000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    sin = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         sin[i] = new float4(0.0f);
                     }
 
-                    cos = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * 10000, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
-                    for (int i = 0; i < 10000; ++i)
+                    cos = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
                     {
                         cos[i] = new float4(1.0f);
                     }
@@ -315,7 +323,7 @@ public void Dispose()
 
             public static void CommonTestFunction(ref Arguments args)
             {
-                for (int i = 0; i < 10000; ++i)
+                for (int i = 0; i < iterations; ++i)
                 {
                     math.sincos(args.sin[i], out args.sin[i], out args.cos[i]);
                 }

From 429f5308338792b8ae3d2e2168da901337044359 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Mon, 6 Dec 2021 10:25:26 -0800
Subject: [PATCH 11/94] Avoid using union structs for asfloat(int) and friends
 (#206)

Remove the use of union structs in asuint() and similar methods. Instead, reinterpret the value with type punning so mono generates better code.
---
 src/CHANGELOG.md                              |    1 +
 .../VectorGenerator.cs                        |  216 +-
 .../TestConversions.gen.cs                    |   18 +
 .../TestFastInverse.gen.cs                    |    4 +
 .../TestHash.gen.cs                           |   26 +
 .../TestInverse.gen.cs                        |   14 +
 .../TestMath.gen.cs                           | 2600 ++++++++++++++++-
 .../TestMinMaxAABB.gen.cs                     |    4 +
 .../TestMul.gen.cs                            |   14 +
 .../TestNoise.gen.cs                          |   36 +
 .../TestNormalize.gen.cs                      |   24 +
 .../TestPlane.gen.cs                          |    2 +
 .../TestRandom.gen.cs                         |  144 +-
 .../TestRotation.gen.cs                       |   14 +
 .../TestShuffle.gen.cs                        |    6 +
 .../TestTranspose.gen.cs                      |   12 +
 .../TestTrig.gen.cs                           |    8 +
 src/Unity.Mathematics/math.cs                 |  238 +-
 18 files changed, 3165 insertions(+), 216 deletions(-)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index f780369d..b86d2ff8 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -6,6 +6,7 @@
 * Added `math.orthonormal_basis()` to compute an orthonormal basis from a single unit length vector.
 * Added `math.sign(x)` for int, int2, int3 and int4.
 ### Changed
+* `asfloat(uint)`, `asuint(float)`, `asint(float)` and other related methods are now faster in mono without Burst. Other methods which use these will see a performance improvement.
 ### Deprecated
 ### Removed
 ### Fixed
diff --git a/src/Unity.Mathematics.CodeGen/VectorGenerator.cs b/src/Unity.Mathematics.CodeGen/VectorGenerator.cs
index 74ca911d..1a696c16 100644
--- a/src/Unity.Mathematics.CodeGen/VectorGenerator.cs
+++ b/src/Unity.Mathematics.CodeGen/VectorGenerator.cs
@@ -3295,55 +3295,43 @@ void GenerateRandomPerformanceTests(StringBuilder str)
             BeginPerformanceTestCodeGen(str, "TestRandom");
 
             GeneratePerformanceTest(str, "Random_NextUint", new PerformanceTestArrayArgument[] {
-                new PerformanceTestArrayArgument { m_ElementType = "Random", m_MemberName = "rng", m_ElementInitializer = "new Unity.Mathematics.Random(1)" },
                 new PerformanceTestArrayArgument { m_ElementType = "uint", m_MemberName = "u", m_ElementInitializer = "0" },
-            }, "args.u[i] = args.rng[i].NextUInt();", 10000);
+            }, "args.u[i] = args.rng.NextUInt();", 10000);
             GeneratePerformanceTest(str, "Random_NextUint2", new PerformanceTestArrayArgument[] {
-                new PerformanceTestArrayArgument { m_ElementType = "Random", m_MemberName = "rng", m_ElementInitializer = "new Unity.Mathematics.Random(1)" },
                 new PerformanceTestArrayArgument { m_ElementType = "uint2", m_MemberName = "u", m_ElementInitializer = "0" },
-            }, "args.u[i] = args.rng[i].NextUInt2();", 10000);
+            }, "args.u[i] = args.rng.NextUInt2();", 10000);
             GeneratePerformanceTest(str, "Random_NextUint3", new PerformanceTestArrayArgument[] {
-                new PerformanceTestArrayArgument { m_ElementType = "Random", m_MemberName = "rng", m_ElementInitializer = "new Unity.Mathematics.Random(1)" },
                 new PerformanceTestArrayArgument { m_ElementType = "uint3", m_MemberName = "u", m_ElementInitializer = "0" },
-            }, "args.u[i] = args.rng[i].NextUInt3();", 10000);
+            }, "args.u[i] = args.rng.NextUInt3();", 10000);
             GeneratePerformanceTest(str, "Random_NextUint4", new PerformanceTestArrayArgument[] {
-                new PerformanceTestArrayArgument { m_ElementType = "Random", m_MemberName = "rng", m_ElementInitializer = "new Unity.Mathematics.Random(1)" },
                 new PerformanceTestArrayArgument { m_ElementType = "uint4", m_MemberName = "u", m_ElementInitializer = "0" },
-            }, "args.u[i] = args.rng[i].NextUInt4();", 10000);
+            }, "args.u[i] = args.rng.NextUInt4();", 10000);
 
             GeneratePerformanceTest(str, "Random_NextFloat", new PerformanceTestArrayArgument[] {
-                new PerformanceTestArrayArgument { m_ElementType = "Random", m_MemberName = "rng", m_ElementInitializer = "new Unity.Mathematics.Random(1)" },
                 new PerformanceTestArrayArgument { m_ElementType = "float", m_MemberName = "f", m_ElementInitializer = "0.0f" },
-            }, "args.f[i] = args.rng[i].NextFloat();", 10000);
+            }, "args.f[i] = args.rng.NextFloat();", 10000);
             GeneratePerformanceTest(str, "Random_NextFloat2", new PerformanceTestArrayArgument[] {
-                new PerformanceTestArrayArgument { m_ElementType = "Random", m_MemberName = "rng", m_ElementInitializer = "new Unity.Mathematics.Random(1)" },
                 new PerformanceTestArrayArgument { m_ElementType = "float2", m_MemberName = "f", m_ElementInitializer = "new float2(0.0f)" },
-            }, "args.f[i] = args.rng[i].NextFloat2();", 10000);
+            }, "args.f[i] = args.rng.NextFloat2();", 10000);
             GeneratePerformanceTest(str, "Random_NextFloat3", new PerformanceTestArrayArgument[] {
-                new PerformanceTestArrayArgument { m_ElementType = "Random", m_MemberName = "rng", m_ElementInitializer = "new Unity.Mathematics.Random(1)" },
                 new PerformanceTestArrayArgument { m_ElementType = "float3", m_MemberName = "f", m_ElementInitializer = "new float3(0.0f)" },
-            }, "args.f[i] = args.rng[i].NextFloat3();", 10000);
+            }, "args.f[i] = args.rng.NextFloat3();", 10000);
             GeneratePerformanceTest(str, "Random_NextFloat4", new PerformanceTestArrayArgument[] {
-                new PerformanceTestArrayArgument { m_ElementType = "Random", m_MemberName = "rng", m_ElementInitializer = "new Unity.Mathematics.Random(1)" },
                 new PerformanceTestArrayArgument { m_ElementType = "float4", m_MemberName = "f", m_ElementInitializer = "new float4(0.0f)" },
-            }, "args.f[i] = args.rng[i].NextFloat4();", 10000);
+            }, "args.f[i] = args.rng.NextFloat4();", 10000);
 
             GeneratePerformanceTest(str, "Random_NextDouble", new PerformanceTestArrayArgument[] {
-                new PerformanceTestArrayArgument { m_ElementType = "Random", m_MemberName = "rng", m_ElementInitializer = "new Unity.Mathematics.Random(1)" },
                 new PerformanceTestArrayArgument { m_ElementType = "double", m_MemberName = "f", m_ElementInitializer = "0.0" },
-            }, "args.f[i] = args.rng[i].NextDouble();", 10000);
+            }, "args.f[i] = args.rng.NextDouble();", 10000);
             GeneratePerformanceTest(str, "Random_NextDouble2", new PerformanceTestArrayArgument[] {
-                new PerformanceTestArrayArgument { m_ElementType = "Random", m_MemberName = "rng", m_ElementInitializer = "new Unity.Mathematics.Random(1)" },
                 new PerformanceTestArrayArgument { m_ElementType = "double2", m_MemberName = "f", m_ElementInitializer = "new double2(0.0)" },
-            }, "args.f[i] = args.rng[i].NextDouble2();", 10000);
+            }, "args.f[i] = args.rng.NextDouble2();", 10000);
             GeneratePerformanceTest(str, "Random_NextDouble3", new PerformanceTestArrayArgument[] {
-                new PerformanceTestArrayArgument { m_ElementType = "Random", m_MemberName = "rng", m_ElementInitializer = "new Unity.Mathematics.Random(1)" },
                 new PerformanceTestArrayArgument { m_ElementType = "double3", m_MemberName = "f", m_ElementInitializer = "new double3(0.0)" },
-            }, "args.f[i] = args.rng[i].NextDouble3();", 10000);
+            }, "args.f[i] = args.rng.NextDouble3();", 10000);
             GeneratePerformanceTest(str, "Random_NextDouble4", new PerformanceTestArrayArgument[] {
-                new PerformanceTestArrayArgument { m_ElementType = "Random", m_MemberName = "rng", m_ElementInitializer = "new Unity.Mathematics.Random(1)" },
                 new PerformanceTestArrayArgument { m_ElementType = "double4", m_MemberName = "f", m_ElementInitializer = "new double4(0.0)" },
-            }, "args.f[i] = args.rng[i].NextDouble4();", 10000);
+            }, "args.f[i] = args.rng.NextDouble4();", 10000);
 
             EndPerformanceTestCodeGen(str);
         }
@@ -3691,22 +3679,186 @@ public void GenerateMathPerformanceTests(StringBuilder str)
 
             GeneratePerformanceTest(str, "orthonormal_basis_float", new PerformanceTestArrayArgument[]
             {
-                // This rng array is totally wasteful since we create loopIterations of them when we just need one.
-                new PerformanceTestArrayArgument { m_ElementType = "Random", m_MemberName = "rng", m_ElementInitializer = "new Random(1234u)" },
-                new PerformanceTestArrayArgument { m_ElementType = "float3", m_MemberName = "v1", m_ElementInitializer = "rng[0].NextFloat3Direction()" },
+                new PerformanceTestArrayArgument { m_ElementType = "float3", m_MemberName = "v1", m_ElementInitializer = "rng.NextFloat3Direction()" },
                 new PerformanceTestArrayArgument { m_ElementType = "float3", m_MemberName = "v2", m_ElementInitializer = "new float3()" },
                 new PerformanceTestArrayArgument { m_ElementType = "float3", m_MemberName = "v3", m_ElementInitializer = "new float3()" },
             }, "math.orthonormal_basis(args.v1[i], out args.v2[i], out args.v3[i]);", 1000000);
 
             GeneratePerformanceTest(str, "orthonormal_basis_double", new PerformanceTestArrayArgument[]
             {
-                // This rng array is totally wasteful since we create loopIterations of them when we just need one.
-                new PerformanceTestArrayArgument { m_ElementType = "Random", m_MemberName = "rng", m_ElementInitializer = "new Random(1234u)" },
-                new PerformanceTestArrayArgument { m_ElementType = "double3", m_MemberName = "v1", m_ElementInitializer = "rng[0].NextDouble3Direction()" },
+                new PerformanceTestArrayArgument { m_ElementType = "double3", m_MemberName = "v1", m_ElementInitializer = "rng.NextDouble3Direction()" },
                 new PerformanceTestArrayArgument { m_ElementType = "double3", m_MemberName = "v2", m_ElementInitializer = "new double()" },
                 new PerformanceTestArrayArgument { m_ElementType = "double3", m_MemberName = "v3", m_ElementInitializer = "new double()" },
             }, "math.orthonormal_basis(args.v1[i], out args.v2[i], out args.v3[i]);", 1000000);
 
+            GeneratePerformanceTest(str, "asuint_float", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "uint", m_MemberName = "result", m_ElementInitializer = "new uint()" },
+                new PerformanceTestArrayArgument { m_ElementType = "float", m_MemberName = "v", m_ElementInitializer = "rng.NextFloat(-1.0f, 1.0f)" },
+            }, "args.result[i] = math.asuint(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asuint_float2", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "uint2", m_MemberName = "result", m_ElementInitializer = "new uint2()" },
+                new PerformanceTestArrayArgument { m_ElementType = "float2", m_MemberName = "v", m_ElementInitializer = "rng.NextFloat2(-1.0f, 1.0f)" },
+            }, "args.result[i] = math.asuint(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asuint_float3", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "uint3", m_MemberName = "result", m_ElementInitializer = "new uint3()" },
+                new PerformanceTestArrayArgument { m_ElementType = "float3", m_MemberName = "v", m_ElementInitializer = "rng.NextFloat3(-1.0f, 1.0f)" },
+            }, "args.result[i] = math.asuint(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asuint_float4", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "uint4", m_MemberName = "result", m_ElementInitializer = "new uint4()" },
+                new PerformanceTestArrayArgument { m_ElementType = "float4", m_MemberName = "v", m_ElementInitializer = "rng.NextFloat4(-1.0f, 1.0f)" },
+            }, "args.result[i] = math.asuint(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asint_float", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "int", m_MemberName = "result", m_ElementInitializer = "new int()" },
+                new PerformanceTestArrayArgument { m_ElementType = "float", m_MemberName = "v", m_ElementInitializer = "rng.NextFloat(-1.0f, 1.0f)" },
+            }, "args.result[i] = math.asint(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asint_float2", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "int2", m_MemberName = "result", m_ElementInitializer = "new int2()" },
+                new PerformanceTestArrayArgument { m_ElementType = "float2", m_MemberName = "v", m_ElementInitializer = "rng.NextFloat2(-1.0f, 1.0f)" },
+            }, "args.result[i] = math.asint(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asint_float3", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "int3", m_MemberName = "result", m_ElementInitializer = "new int3()" },
+                new PerformanceTestArrayArgument { m_ElementType = "float3", m_MemberName = "v", m_ElementInitializer = "rng.NextFloat3(-1.0f, 1.0f)" },
+            }, "args.result[i] = math.asint(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asint_float4", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "int4", m_MemberName = "result", m_ElementInitializer = "new int4()" },
+                new PerformanceTestArrayArgument { m_ElementType = "float4", m_MemberName = "v", m_ElementInitializer = "rng.NextFloat4(-1.0f, 1.0f)" },
+            }, "args.result[i] = math.asint(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asfloat_uint", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "float", m_MemberName = "result", m_ElementInitializer = "new uint()" },
+                new PerformanceTestArrayArgument { m_ElementType = "uint", m_MemberName = "v", m_ElementInitializer = "rng.NextUInt()" },
+            }, "args.result[i] = math.asfloat(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asfloat_uint2", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "float2", m_MemberName = "result", m_ElementInitializer = "new uint2()" },
+                new PerformanceTestArrayArgument { m_ElementType = "uint2", m_MemberName = "v", m_ElementInitializer = "rng.NextUInt2()" },
+            }, "args.result[i] = math.asfloat(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asfloat_uint3", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "float3", m_MemberName = "result", m_ElementInitializer = "new uint3()" },
+                new PerformanceTestArrayArgument { m_ElementType = "uint3", m_MemberName = "v", m_ElementInitializer = "rng.NextUInt3()" },
+            }, "args.result[i] = math.asfloat(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asfloat_uint4", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "float4", m_MemberName = "result", m_ElementInitializer = "new uint4()" },
+                new PerformanceTestArrayArgument { m_ElementType = "uint4", m_MemberName = "v", m_ElementInitializer = "rng.NextUInt4()" },
+            }, "args.result[i] = math.asfloat(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asfloat_int", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "float", m_MemberName = "result", m_ElementInitializer = "new int()" },
+                new PerformanceTestArrayArgument { m_ElementType = "int", m_MemberName = "v", m_ElementInitializer = "rng.NextInt()" },
+            }, "args.result[i] = math.asfloat(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asfloat_int2", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "float2", m_MemberName = "result", m_ElementInitializer = "new int2()" },
+                new PerformanceTestArrayArgument { m_ElementType = "int2", m_MemberName = "v", m_ElementInitializer = "rng.NextInt2()" },
+            }, "args.result[i] = math.asfloat(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asfloat_int3", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "float3", m_MemberName = "result", m_ElementInitializer = "new int3()" },
+                new PerformanceTestArrayArgument { m_ElementType = "int3", m_MemberName = "v", m_ElementInitializer = "rng.NextInt3()" },
+            }, "args.result[i] = math.asfloat(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asfloat_int4", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "float4", m_MemberName = "result", m_ElementInitializer = "new int4()" },
+                new PerformanceTestArrayArgument { m_ElementType = "int4", m_MemberName = "v", m_ElementInitializer = "rng.NextInt4()" },
+            }, "args.result[i] = math.asfloat(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asdouble_ulong", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "double", m_MemberName = "result", m_ElementInitializer = "new double()" },
+                new PerformanceTestArrayArgument { m_ElementType = "ulong", m_MemberName = "v", m_ElementInitializer = "rng.NextUInt()" },
+            }, "args.result[i] = math.asdouble(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asdouble_long", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "double", m_MemberName = "result", m_ElementInitializer = "new double()" },
+                new PerformanceTestArrayArgument { m_ElementType = "long", m_MemberName = "v", m_ElementInitializer = "rng.NextInt()" },
+            }, "args.result[i] = math.asdouble(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "aslong_double", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "long", m_MemberName = "result", m_ElementInitializer = "new long()" },
+                new PerformanceTestArrayArgument { m_ElementType = "double", m_MemberName = "v", m_ElementInitializer = "rng.NextDouble(-1.0, 1.0)" },
+            }, "args.result[i] = math.aslong(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asulong_double", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "ulong", m_MemberName = "result", m_ElementInitializer = "new ulong()" },
+                new PerformanceTestArrayArgument { m_ElementType = "double", m_MemberName = "v", m_ElementInitializer = "rng.NextDouble(-1.0, 1.0)" },
+            }, "args.result[i] = math.asulong(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asuint_int", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "uint", m_MemberName = "result", m_ElementInitializer = "new uint()" },
+                new PerformanceTestArrayArgument { m_ElementType = "int", m_MemberName = "v", m_ElementInitializer = "rng.NextInt()" },
+            }, "args.result[i] = math.asuint(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asuint_int2", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "uint2", m_MemberName = "result", m_ElementInitializer = "new uint2()" },
+                new PerformanceTestArrayArgument { m_ElementType = "int2", m_MemberName = "v", m_ElementInitializer = "rng.NextInt2()" },
+            }, "args.result[i] = math.asuint(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asuint_int3", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "uint3", m_MemberName = "result", m_ElementInitializer = "new uint3()" },
+                new PerformanceTestArrayArgument { m_ElementType = "int3", m_MemberName = "v", m_ElementInitializer = "rng.NextInt3()" },
+            }, "args.result[i] = math.asuint(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asuint_int4", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "uint4", m_MemberName = "result", m_ElementInitializer = "new uint4()" },
+                new PerformanceTestArrayArgument { m_ElementType = "int4", m_MemberName = "v", m_ElementInitializer = "rng.NextInt4()" },
+            }, "args.result[i] = math.asuint(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asint_uint", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "int", m_MemberName = "result", m_ElementInitializer = "new int()" },
+                new PerformanceTestArrayArgument { m_ElementType = "uint", m_MemberName = "v", m_ElementInitializer = "rng.NextUInt()" },
+            }, "args.result[i] = math.asint(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asint_uint2", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "int2", m_MemberName = "result", m_ElementInitializer = "new int2()" },
+                new PerformanceTestArrayArgument { m_ElementType = "uint2", m_MemberName = "v", m_ElementInitializer = "rng.NextUInt2()" },
+            }, "args.result[i] = math.asint(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asint_uint3", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "int3", m_MemberName = "result", m_ElementInitializer = "new int3()" },
+                new PerformanceTestArrayArgument { m_ElementType = "uint3", m_MemberName = "v", m_ElementInitializer = "rng.NextUInt3()" },
+            }, "args.result[i] = math.asint(args.v[i]);", 400000);
+
+            GeneratePerformanceTest(str, "asint_uint4", new[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "int4", m_MemberName = "result", m_ElementInitializer = "new int4()" },
+                new PerformanceTestArrayArgument { m_ElementType = "uint4", m_MemberName = "v", m_ElementInitializer = "rng.NextUInt4()" },
+            }, "args.result[i] = math.asint(args.v[i]);", 400000);
+
             EndPerformanceTestCodeGen(str);
         }
 
@@ -3717,7 +3869,7 @@ public struct PerformanceTestArrayArgument
             public string m_ElementInitializer;
         }
 
-        void GeneratePerformanceTest(StringBuilder str, string testName, PerformanceTestArrayArgument[] testArguments, string loopBody, int loopIterations)
+        void GeneratePerformanceTest(StringBuilder str, string testName, PerformanceTestArrayArgument[] testArguments, string loopBody, int loopIterations, uint rngSeed = 1u)
         {
             str.AppendFormat("\t\t[BurstCompile(CompileSynchronously = true)]\n");
             str.AppendFormat("\t\tpublic unsafe class {0}\n", testName);
@@ -3725,6 +3877,7 @@ void GeneratePerformanceTest(StringBuilder str, string testName, PerformanceTest
             str.AppendFormat("\t\t\tpublic const int iterations = {0};\n\n", loopIterations);
             str.AppendFormat("\t\t\tpublic struct Arguments : IDisposable\n");
             str.AppendFormat("\t\t\t{{\n");
+            str.AppendFormat("\t\t\t\tpublic Random rng;\n");
 
             foreach (var argument in testArguments)
             {
@@ -3734,6 +3887,7 @@ void GeneratePerformanceTest(StringBuilder str, string testName, PerformanceTest
             str.AppendFormat("\n");
             str.AppendFormat("\t\t\t\tpublic void Init()\n");
             str.AppendFormat("\t\t\t\t{{\n");
+            str.AppendFormat("\t\t\t\t\trng = new Random({0});\n", rngSeed);
 
             foreach (var argument in testArguments)
             {
diff --git a/src/Unity.Mathematics.PerformanceTests/TestConversions.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestConversions.gen.cs
index 20193726..3050d7f5 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestConversions.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestConversions.gen.cs
@@ -25,11 +25,13 @@ public unsafe class quaternion_to_float3x3
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public quaternion* q;
                 public float3x3* f3x3;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -115,11 +117,13 @@ public unsafe class float3x3_to_quaternion
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public quaternion* q;
                 public float3x3* f3x3;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -205,11 +209,13 @@ public unsafe class float4_to_half4
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4* f4;
                 public half4* h4;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     f4 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -295,11 +301,13 @@ public unsafe class half4_to_float4
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4* f4;
                 public half4* h4;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     f4 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -385,12 +393,14 @@ public unsafe class quaternion_to_RigidTransform
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public quaternion* q;
                 public RigidTransform* rt;
                 public float3* pos;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -483,11 +493,13 @@ public unsafe class quaternion_to_float4x4
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public quaternion* q;
                 public float4x4* f4x4;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -573,12 +585,14 @@ public unsafe class float4x4_to_quaternion
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public quaternion* q;
                 public float4x4* f4x4;
                 public float3* f3;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -671,11 +685,13 @@ public unsafe class float4_to_uint4
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4* f4;
                 public uint4* u4;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     f4 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -761,11 +777,13 @@ public unsafe class uint4_to_float4
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4* f4;
                 public uint4* u4;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     f4 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
diff --git a/src/Unity.Mathematics.PerformanceTests/TestFastInverse.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestFastInverse.gen.cs
index 62f950f0..570951dd 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestFastInverse.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestFastInverse.gen.cs
@@ -25,10 +25,12 @@ public unsafe class float4x4_fastinverse
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4x4* m1;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m1 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -107,10 +109,12 @@ public unsafe class double4x4_fastinverse
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public double4x4* m1;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m1 = (double4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4x4>() * iterations, UnsafeUtility.AlignOf<double4x4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
diff --git a/src/Unity.Mathematics.PerformanceTests/TestHash.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestHash.gen.cs
index 320bda9f..e90cf82c 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestHash.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestHash.gen.cs
@@ -25,11 +25,13 @@ public unsafe class float2_hash
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2* v;
                 public uint* hash;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -115,11 +117,13 @@ public unsafe class float3_hash
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* v;
                 public uint* hash;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -205,11 +209,13 @@ public unsafe class float4_hash
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4* v;
                 public uint* hash;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -295,11 +301,13 @@ public unsafe class double2_hash
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public double2* v;
                 public uint* hash;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (double2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2>() * iterations, UnsafeUtility.AlignOf<double2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -385,11 +393,13 @@ public unsafe class double3_hash
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public double3* v;
                 public uint* hash;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * iterations, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -475,11 +485,13 @@ public unsafe class double4_hash
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public double4* v;
                 public uint* hash;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (double4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4>() * iterations, UnsafeUtility.AlignOf<double4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -565,11 +577,13 @@ public unsafe class float2x2_hash
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2x2* v;
                 public uint* hash;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * iterations, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -655,11 +669,13 @@ public unsafe class float3x3_hash
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3x3* v;
                 public uint* hash;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -745,11 +761,13 @@ public unsafe class float4x4_hash
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4x4* v;
                 public uint* hash;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -835,11 +853,13 @@ public unsafe class float2x2_hashwide
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2x2* v;
                 public uint2* hash;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * iterations, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -925,11 +945,13 @@ public unsafe class float3x3_hashwide
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3x3* v;
                 public uint3* hash;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -1015,11 +1037,13 @@ public unsafe class float4x4_hashwide
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4x4* v;
                 public uint4* hash;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -1105,11 +1129,13 @@ public unsafe class float2_hashwide
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2* v;
                 public uint2* hash;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
diff --git a/src/Unity.Mathematics.PerformanceTests/TestInverse.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestInverse.gen.cs
index 438bfb75..1359b2a3 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestInverse.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestInverse.gen.cs
@@ -25,10 +25,12 @@ public unsafe class float4x4_inverse
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4x4* m1;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m1 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -107,10 +109,12 @@ public unsafe class float3x3_inverse
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3x3* m1;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m1 = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -189,10 +193,12 @@ public unsafe class float2x2_inverse
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2x2* m1;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m1 = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * iterations, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -271,10 +277,12 @@ public unsafe class double4x4_inverse
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public double4x4* m1;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m1 = (double4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4x4>() * iterations, UnsafeUtility.AlignOf<double4x4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -353,10 +361,12 @@ public unsafe class double3x3_inverse
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public double3x3* m1;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m1 = (double3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3x3>() * iterations, UnsafeUtility.AlignOf<double3x3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -435,10 +445,12 @@ public unsafe class double2x2_inverse
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public double2x2* m1;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m1 = (double2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2x2>() * iterations, UnsafeUtility.AlignOf<double2x2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -517,10 +529,12 @@ public unsafe class quaternion_inverse
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public quaternion* q;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     q = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
diff --git a/src/Unity.Mathematics.PerformanceTests/TestMath.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestMath.gen.cs
index 01376555..d6ad87f5 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestMath.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestMath.gen.cs
@@ -25,23 +25,18 @@ public unsafe class orthonormal_basis_float
 
             public struct Arguments : IDisposable
             {
-                public Random* rng;
+                public Random rng;
                 public float3* v1;
                 public float3* v2;
                 public float3* v3;
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < iterations; ++i)
-                    {
-                        rng[i] = new Random(1234u);
-                    }
-
+                    rng = new Random(1);
                     v1 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
-                        v1[i] = rng[0].NextFloat3Direction();
+                        v1[i] = rng.NextFloat3Direction();
                     }
 
                     v2 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
@@ -60,7 +55,6 @@ public void Init()
 
                 public void Dispose()
                 {
-                    UnsafeUtility.Free(rng, Allocator.Persistent);
                     UnsafeUtility.Free(v1, Allocator.Persistent);
                     UnsafeUtility.Free(v2, Allocator.Persistent);
                     UnsafeUtility.Free(v3, Allocator.Persistent);
@@ -131,23 +125,18 @@ public unsafe class orthonormal_basis_double
 
             public struct Arguments : IDisposable
             {
-                public Random* rng;
+                public Random rng;
                 public double3* v1;
                 public double3* v2;
                 public double3* v3;
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < iterations; ++i)
-                    {
-                        rng[i] = new Random(1234u);
-                    }
-
+                    rng = new Random(1);
                     v1 = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * iterations, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
-                        v1[i] = rng[0].NextDouble3Direction();
+                        v1[i] = rng.NextDouble3Direction();
                     }
 
                     v2 = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * iterations, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
@@ -166,7 +155,6 @@ public void Init()
 
                 public void Dispose()
                 {
-                    UnsafeUtility.Free(rng, Allocator.Persistent);
                     UnsafeUtility.Free(v1, Allocator.Persistent);
                     UnsafeUtility.Free(v2, Allocator.Persistent);
                     UnsafeUtility.Free(v3, Allocator.Persistent);
@@ -220,6 +208,2582 @@ public void orthonormal_basis_double_burst()
             var args = new orthonormal_basis_double.Arguments();
             args.Init();
 
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asuint_float
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public uint* result;
+                public float* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * iterations, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new uint();
+                    }
+
+                    v = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * iterations, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextFloat(-1.0f, 1.0f);
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asuint(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asuint_float_mono()
+        {
+            asuint_float.TestFunction testFunction = asuint_float.MonoTestFunction;
+            var args = new asuint_float.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asuint_float_burst()
+        {
+            FunctionPointer<asuint_float.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asuint_float.TestFunction>(asuint_float.BurstTestFunction);
+            var args = new asuint_float.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asuint_float2
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public uint2* result;
+                public float2* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (uint2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint2>() * iterations, UnsafeUtility.AlignOf<uint2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new uint2();
+                    }
+
+                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextFloat2(-1.0f, 1.0f);
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asuint(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asuint_float2_mono()
+        {
+            asuint_float2.TestFunction testFunction = asuint_float2.MonoTestFunction;
+            var args = new asuint_float2.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asuint_float2_burst()
+        {
+            FunctionPointer<asuint_float2.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asuint_float2.TestFunction>(asuint_float2.BurstTestFunction);
+            var args = new asuint_float2.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asuint_float3
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public uint3* result;
+                public float3* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (uint3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint3>() * iterations, UnsafeUtility.AlignOf<uint3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new uint3();
+                    }
+
+                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextFloat3(-1.0f, 1.0f);
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asuint(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asuint_float3_mono()
+        {
+            asuint_float3.TestFunction testFunction = asuint_float3.MonoTestFunction;
+            var args = new asuint_float3.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asuint_float3_burst()
+        {
+            FunctionPointer<asuint_float3.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asuint_float3.TestFunction>(asuint_float3.BurstTestFunction);
+            var args = new asuint_float3.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asuint_float4
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public uint4* result;
+                public float4* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (uint4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint4>() * iterations, UnsafeUtility.AlignOf<uint4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new uint4();
+                    }
+
+                    v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextFloat4(-1.0f, 1.0f);
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asuint(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asuint_float4_mono()
+        {
+            asuint_float4.TestFunction testFunction = asuint_float4.MonoTestFunction;
+            var args = new asuint_float4.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asuint_float4_burst()
+        {
+            FunctionPointer<asuint_float4.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asuint_float4.TestFunction>(asuint_float4.BurstTestFunction);
+            var args = new asuint_float4.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asint_float
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public int* result;
+                public float* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (int*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int>() * iterations, UnsafeUtility.AlignOf<int>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new int();
+                    }
+
+                    v = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * iterations, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextFloat(-1.0f, 1.0f);
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asint(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asint_float_mono()
+        {
+            asint_float.TestFunction testFunction = asint_float.MonoTestFunction;
+            var args = new asint_float.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asint_float_burst()
+        {
+            FunctionPointer<asint_float.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asint_float.TestFunction>(asint_float.BurstTestFunction);
+            var args = new asint_float.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asint_float2
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public int2* result;
+                public float2* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (int2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int2>() * iterations, UnsafeUtility.AlignOf<int2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new int2();
+                    }
+
+                    v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextFloat2(-1.0f, 1.0f);
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asint(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asint_float2_mono()
+        {
+            asint_float2.TestFunction testFunction = asint_float2.MonoTestFunction;
+            var args = new asint_float2.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asint_float2_burst()
+        {
+            FunctionPointer<asint_float2.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asint_float2.TestFunction>(asint_float2.BurstTestFunction);
+            var args = new asint_float2.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asint_float3
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public int3* result;
+                public float3* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (int3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int3>() * iterations, UnsafeUtility.AlignOf<int3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new int3();
+                    }
+
+                    v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextFloat3(-1.0f, 1.0f);
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asint(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asint_float3_mono()
+        {
+            asint_float3.TestFunction testFunction = asint_float3.MonoTestFunction;
+            var args = new asint_float3.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asint_float3_burst()
+        {
+            FunctionPointer<asint_float3.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asint_float3.TestFunction>(asint_float3.BurstTestFunction);
+            var args = new asint_float3.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asint_float4
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public int4* result;
+                public float4* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (int4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int4>() * iterations, UnsafeUtility.AlignOf<int4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new int4();
+                    }
+
+                    v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextFloat4(-1.0f, 1.0f);
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asint(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asint_float4_mono()
+        {
+            asint_float4.TestFunction testFunction = asint_float4.MonoTestFunction;
+            var args = new asint_float4.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asint_float4_burst()
+        {
+            FunctionPointer<asint_float4.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asint_float4.TestFunction>(asint_float4.BurstTestFunction);
+            var args = new asint_float4.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asfloat_uint
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public float* result;
+                public uint* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * iterations, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new uint();
+                    }
+
+                    v = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * iterations, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextUInt();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asfloat(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asfloat_uint_mono()
+        {
+            asfloat_uint.TestFunction testFunction = asfloat_uint.MonoTestFunction;
+            var args = new asfloat_uint.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asfloat_uint_burst()
+        {
+            FunctionPointer<asfloat_uint.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asfloat_uint.TestFunction>(asfloat_uint.BurstTestFunction);
+            var args = new asfloat_uint.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asfloat_uint2
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public float2* result;
+                public uint2* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new uint2();
+                    }
+
+                    v = (uint2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint2>() * iterations, UnsafeUtility.AlignOf<uint2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextUInt2();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asfloat(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asfloat_uint2_mono()
+        {
+            asfloat_uint2.TestFunction testFunction = asfloat_uint2.MonoTestFunction;
+            var args = new asfloat_uint2.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asfloat_uint2_burst()
+        {
+            FunctionPointer<asfloat_uint2.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asfloat_uint2.TestFunction>(asfloat_uint2.BurstTestFunction);
+            var args = new asfloat_uint2.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asfloat_uint3
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public float3* result;
+                public uint3* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new uint3();
+                    }
+
+                    v = (uint3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint3>() * iterations, UnsafeUtility.AlignOf<uint3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextUInt3();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asfloat(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asfloat_uint3_mono()
+        {
+            asfloat_uint3.TestFunction testFunction = asfloat_uint3.MonoTestFunction;
+            var args = new asfloat_uint3.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asfloat_uint3_burst()
+        {
+            FunctionPointer<asfloat_uint3.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asfloat_uint3.TestFunction>(asfloat_uint3.BurstTestFunction);
+            var args = new asfloat_uint3.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asfloat_uint4
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public float4* result;
+                public uint4* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new uint4();
+                    }
+
+                    v = (uint4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint4>() * iterations, UnsafeUtility.AlignOf<uint4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextUInt4();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asfloat(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asfloat_uint4_mono()
+        {
+            asfloat_uint4.TestFunction testFunction = asfloat_uint4.MonoTestFunction;
+            var args = new asfloat_uint4.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asfloat_uint4_burst()
+        {
+            FunctionPointer<asfloat_uint4.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asfloat_uint4.TestFunction>(asfloat_uint4.BurstTestFunction);
+            var args = new asfloat_uint4.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asfloat_int
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public float* result;
+                public int* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * iterations, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new int();
+                    }
+
+                    v = (int*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int>() * iterations, UnsafeUtility.AlignOf<int>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextInt();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asfloat(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asfloat_int_mono()
+        {
+            asfloat_int.TestFunction testFunction = asfloat_int.MonoTestFunction;
+            var args = new asfloat_int.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asfloat_int_burst()
+        {
+            FunctionPointer<asfloat_int.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asfloat_int.TestFunction>(asfloat_int.BurstTestFunction);
+            var args = new asfloat_int.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asfloat_int2
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public float2* result;
+                public int2* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new int2();
+                    }
+
+                    v = (int2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int2>() * iterations, UnsafeUtility.AlignOf<int2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextInt2();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asfloat(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asfloat_int2_mono()
+        {
+            asfloat_int2.TestFunction testFunction = asfloat_int2.MonoTestFunction;
+            var args = new asfloat_int2.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asfloat_int2_burst()
+        {
+            FunctionPointer<asfloat_int2.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asfloat_int2.TestFunction>(asfloat_int2.BurstTestFunction);
+            var args = new asfloat_int2.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asfloat_int3
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public float3* result;
+                public int3* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new int3();
+                    }
+
+                    v = (int3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int3>() * iterations, UnsafeUtility.AlignOf<int3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextInt3();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asfloat(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asfloat_int3_mono()
+        {
+            asfloat_int3.TestFunction testFunction = asfloat_int3.MonoTestFunction;
+            var args = new asfloat_int3.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asfloat_int3_burst()
+        {
+            FunctionPointer<asfloat_int3.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asfloat_int3.TestFunction>(asfloat_int3.BurstTestFunction);
+            var args = new asfloat_int3.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asfloat_int4
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public float4* result;
+                public int4* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new int4();
+                    }
+
+                    v = (int4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int4>() * iterations, UnsafeUtility.AlignOf<int4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextInt4();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asfloat(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asfloat_int4_mono()
+        {
+            asfloat_int4.TestFunction testFunction = asfloat_int4.MonoTestFunction;
+            var args = new asfloat_int4.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asfloat_int4_burst()
+        {
+            FunctionPointer<asfloat_int4.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asfloat_int4.TestFunction>(asfloat_int4.BurstTestFunction);
+            var args = new asfloat_int4.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asdouble_ulong
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public double* result;
+                public ulong* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (double*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double>() * iterations, UnsafeUtility.AlignOf<double>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new double();
+                    }
+
+                    v = (ulong*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<ulong>() * iterations, UnsafeUtility.AlignOf<ulong>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextUInt();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asdouble(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asdouble_ulong_mono()
+        {
+            asdouble_ulong.TestFunction testFunction = asdouble_ulong.MonoTestFunction;
+            var args = new asdouble_ulong.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asdouble_ulong_burst()
+        {
+            FunctionPointer<asdouble_ulong.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asdouble_ulong.TestFunction>(asdouble_ulong.BurstTestFunction);
+            var args = new asdouble_ulong.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asdouble_long
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public double* result;
+                public long* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (double*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double>() * iterations, UnsafeUtility.AlignOf<double>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new double();
+                    }
+
+                    v = (long*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<long>() * iterations, UnsafeUtility.AlignOf<long>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextInt();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asdouble(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asdouble_long_mono()
+        {
+            asdouble_long.TestFunction testFunction = asdouble_long.MonoTestFunction;
+            var args = new asdouble_long.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asdouble_long_burst()
+        {
+            FunctionPointer<asdouble_long.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asdouble_long.TestFunction>(asdouble_long.BurstTestFunction);
+            var args = new asdouble_long.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class aslong_double
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public long* result;
+                public double* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (long*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<long>() * iterations, UnsafeUtility.AlignOf<long>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new long();
+                    }
+
+                    v = (double*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double>() * iterations, UnsafeUtility.AlignOf<double>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextDouble(-1.0, 1.0);
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.aslong(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void aslong_double_mono()
+        {
+            aslong_double.TestFunction testFunction = aslong_double.MonoTestFunction;
+            var args = new aslong_double.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void aslong_double_burst()
+        {
+            FunctionPointer<aslong_double.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<aslong_double.TestFunction>(aslong_double.BurstTestFunction);
+            var args = new aslong_double.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asulong_double
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public ulong* result;
+                public double* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (ulong*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<ulong>() * iterations, UnsafeUtility.AlignOf<ulong>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new ulong();
+                    }
+
+                    v = (double*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double>() * iterations, UnsafeUtility.AlignOf<double>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextDouble(-1.0, 1.0);
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asulong(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asulong_double_mono()
+        {
+            asulong_double.TestFunction testFunction = asulong_double.MonoTestFunction;
+            var args = new asulong_double.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asulong_double_burst()
+        {
+            FunctionPointer<asulong_double.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asulong_double.TestFunction>(asulong_double.BurstTestFunction);
+            var args = new asulong_double.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asuint_int
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public uint* result;
+                public int* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * iterations, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new uint();
+                    }
+
+                    v = (int*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int>() * iterations, UnsafeUtility.AlignOf<int>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextInt();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asuint(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asuint_int_mono()
+        {
+            asuint_int.TestFunction testFunction = asuint_int.MonoTestFunction;
+            var args = new asuint_int.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asuint_int_burst()
+        {
+            FunctionPointer<asuint_int.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asuint_int.TestFunction>(asuint_int.BurstTestFunction);
+            var args = new asuint_int.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asuint_int2
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public uint2* result;
+                public int2* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (uint2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint2>() * iterations, UnsafeUtility.AlignOf<uint2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new uint2();
+                    }
+
+                    v = (int2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int2>() * iterations, UnsafeUtility.AlignOf<int2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextInt2();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asuint(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asuint_int2_mono()
+        {
+            asuint_int2.TestFunction testFunction = asuint_int2.MonoTestFunction;
+            var args = new asuint_int2.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asuint_int2_burst()
+        {
+            FunctionPointer<asuint_int2.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asuint_int2.TestFunction>(asuint_int2.BurstTestFunction);
+            var args = new asuint_int2.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asuint_int3
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public uint3* result;
+                public int3* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (uint3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint3>() * iterations, UnsafeUtility.AlignOf<uint3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new uint3();
+                    }
+
+                    v = (int3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int3>() * iterations, UnsafeUtility.AlignOf<int3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextInt3();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asuint(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asuint_int3_mono()
+        {
+            asuint_int3.TestFunction testFunction = asuint_int3.MonoTestFunction;
+            var args = new asuint_int3.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asuint_int3_burst()
+        {
+            FunctionPointer<asuint_int3.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asuint_int3.TestFunction>(asuint_int3.BurstTestFunction);
+            var args = new asuint_int3.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asuint_int4
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public uint4* result;
+                public int4* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (uint4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint4>() * iterations, UnsafeUtility.AlignOf<uint4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new uint4();
+                    }
+
+                    v = (int4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int4>() * iterations, UnsafeUtility.AlignOf<int4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextInt4();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asuint(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asuint_int4_mono()
+        {
+            asuint_int4.TestFunction testFunction = asuint_int4.MonoTestFunction;
+            var args = new asuint_int4.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asuint_int4_burst()
+        {
+            FunctionPointer<asuint_int4.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asuint_int4.TestFunction>(asuint_int4.BurstTestFunction);
+            var args = new asuint_int4.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asint_uint
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public int* result;
+                public uint* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (int*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int>() * iterations, UnsafeUtility.AlignOf<int>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new int();
+                    }
+
+                    v = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * iterations, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextUInt();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asint(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asint_uint_mono()
+        {
+            asint_uint.TestFunction testFunction = asint_uint.MonoTestFunction;
+            var args = new asint_uint.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asint_uint_burst()
+        {
+            FunctionPointer<asint_uint.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asint_uint.TestFunction>(asint_uint.BurstTestFunction);
+            var args = new asint_uint.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asint_uint2
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public int2* result;
+                public uint2* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (int2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int2>() * iterations, UnsafeUtility.AlignOf<int2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new int2();
+                    }
+
+                    v = (uint2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint2>() * iterations, UnsafeUtility.AlignOf<uint2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextUInt2();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asint(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asint_uint2_mono()
+        {
+            asint_uint2.TestFunction testFunction = asint_uint2.MonoTestFunction;
+            var args = new asint_uint2.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asint_uint2_burst()
+        {
+            FunctionPointer<asint_uint2.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asint_uint2.TestFunction>(asint_uint2.BurstTestFunction);
+            var args = new asint_uint2.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asint_uint3
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public int3* result;
+                public uint3* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (int3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int3>() * iterations, UnsafeUtility.AlignOf<int3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new int3();
+                    }
+
+                    v = (uint3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint3>() * iterations, UnsafeUtility.AlignOf<uint3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextUInt3();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asint(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asint_uint3_mono()
+        {
+            asint_uint3.TestFunction testFunction = asint_uint3.MonoTestFunction;
+            var args = new asint_uint3.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asint_uint3_burst()
+        {
+            FunctionPointer<asint_uint3.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asint_uint3.TestFunction>(asint_uint3.BurstTestFunction);
+            var args = new asint_uint3.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class asint_uint4
+        {
+            public const int iterations = 400000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public int4* result;
+                public uint4* v;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    result = (int4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<int4>() * iterations, UnsafeUtility.AlignOf<int4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new int4();
+                    }
+
+                    v = (uint4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint4>() * iterations, UnsafeUtility.AlignOf<uint4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        v[i] = rng.NextUInt4();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                    UnsafeUtility.Free(v, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.asint(args.v[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void asint_uint4_mono()
+        {
+            asint_uint4.TestFunction testFunction = asint_uint4.MonoTestFunction;
+            var args = new asint_uint4.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void asint_uint4_burst()
+        {
+            FunctionPointer<asint_uint4.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<asint_uint4.TestFunction>(asint_uint4.BurstTestFunction);
+            var args = new asint_uint4.Arguments();
+            args.Init();
+
             var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
             {
                 testFunction.Invoke(ref args);
diff --git a/src/Unity.Mathematics.PerformanceTests/TestMinMaxAABB.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestMinMaxAABB.gen.cs
index b964fec4..ab4406c2 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestMinMaxAABB.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestMinMaxAABB.gen.cs
@@ -25,10 +25,12 @@ public unsafe class Transform_float4x4
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public Geometry.MinMaxAABB* a;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     a = (Geometry.MinMaxAABB*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Geometry.MinMaxAABB>() * iterations, UnsafeUtility.AlignOf<Geometry.MinMaxAABB>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -107,10 +109,12 @@ public unsafe class Transform_float3x3
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public Geometry.MinMaxAABB* a;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     a = (Geometry.MinMaxAABB*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Geometry.MinMaxAABB>() * iterations, UnsafeUtility.AlignOf<Geometry.MinMaxAABB>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
diff --git a/src/Unity.Mathematics.PerformanceTests/TestMul.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestMul.gen.cs
index 06c29893..2cd2c55a 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestMul.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestMul.gen.cs
@@ -25,11 +25,13 @@ public unsafe class float4x4_float4x4
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4x4* m1;
                 public float4x4* m2;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m1 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -115,11 +117,13 @@ public unsafe class float4x4_float4
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4x4* m1;
                 public float4* m2;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m1 = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -205,11 +209,13 @@ public unsafe class quaternion_quaternion
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public quaternion* q1;
                 public quaternion* q2;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     q1 = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -295,11 +301,13 @@ public unsafe class float3x3_float3x3
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3x3* m1;
                 public float3x3* m2;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m1 = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -385,11 +393,13 @@ public unsafe class float2x2_float2x2
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2x2* m1;
                 public float2x2* m2;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m1 = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * iterations, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -475,11 +485,13 @@ public unsafe class float3x3_float3
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3x3* m1;
                 public float3* m2;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m1 = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -565,11 +577,13 @@ public unsafe class float2x2_float2
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2x2* m1;
                 public float2* m2;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m1 = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * iterations, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
diff --git a/src/Unity.Mathematics.PerformanceTests/TestNoise.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestNoise.gen.cs
index 988d06a6..d87c6612 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestNoise.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestNoise.gen.cs
@@ -25,10 +25,12 @@ public unsafe class snoise2D
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -107,10 +109,12 @@ public unsafe class snoise3D
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -189,10 +193,12 @@ public unsafe class snoise4D
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -271,11 +277,13 @@ public unsafe class snoise3Dgrad
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* v;
                 public float3* gradient;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -361,10 +369,12 @@ public unsafe class cnoise2D
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -443,10 +453,12 @@ public unsafe class cnoise3D
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -525,10 +537,12 @@ public unsafe class cnoise4D
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -607,10 +621,12 @@ public unsafe class pnoise2D
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -689,10 +705,12 @@ public unsafe class pnoise3D
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -771,10 +789,12 @@ public unsafe class pnoise4D
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -853,10 +873,12 @@ public unsafe class cellular2D
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -935,10 +957,12 @@ public unsafe class cellular3D
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -1017,10 +1041,12 @@ public unsafe class cellular2x2
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -1099,10 +1125,12 @@ public unsafe class cellular2x2x2
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -1181,10 +1209,12 @@ public unsafe class psrdnoise
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -1263,10 +1293,12 @@ public unsafe class psrnoise
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -1345,10 +1377,12 @@ public unsafe class srdnoise
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -1427,10 +1461,12 @@ public unsafe class srnoise
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
diff --git a/src/Unity.Mathematics.PerformanceTests/TestNormalize.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestNormalize.gen.cs
index b2915796..5f70e74d 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestNormalize.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestNormalize.gen.cs
@@ -25,10 +25,12 @@ public unsafe class float4_normalize
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -107,10 +109,12 @@ public unsafe class float3_normalize
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -189,10 +193,12 @@ public unsafe class float2_normalize
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -271,10 +277,12 @@ public unsafe class double4_normalize
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public double4* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (double4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4>() * iterations, UnsafeUtility.AlignOf<double4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -353,10 +361,12 @@ public unsafe class double3_normalize
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public double3* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * iterations, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -435,10 +445,12 @@ public unsafe class double2_normalize
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public double2* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (double2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2>() * iterations, UnsafeUtility.AlignOf<double2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -517,10 +529,12 @@ public unsafe class float4_normalizesafe
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -599,10 +613,12 @@ public unsafe class float3_normalizesafe
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -681,10 +697,12 @@ public unsafe class float2_normalizesafe
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -763,10 +781,12 @@ public unsafe class double4_normalizesafe
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public double4* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (double4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4>() * iterations, UnsafeUtility.AlignOf<double4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -845,10 +865,12 @@ public unsafe class double3_normalizesafe
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public double3* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * iterations, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -927,10 +949,12 @@ public unsafe class double2_normalizesafe
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public double2* v;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (double2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2>() * iterations, UnsafeUtility.AlignOf<double2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
diff --git a/src/Unity.Mathematics.PerformanceTests/TestPlane.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestPlane.gen.cs
index cb29c3b2..59b6949c 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestPlane.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestPlane.gen.cs
@@ -25,10 +25,12 @@ public unsafe class Normalize_Plane
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public Plane* p;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     p = (Plane*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Plane>() * iterations, UnsafeUtility.AlignOf<Plane>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
diff --git a/src/Unity.Mathematics.PerformanceTests/TestRandom.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestRandom.gen.cs
index ee29e432..c318f90f 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestRandom.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestRandom.gen.cs
@@ -25,17 +25,12 @@ public unsafe class Random_NextUint
 
             public struct Arguments : IDisposable
             {
-                public Random* rng;
+                public Random rng;
                 public uint* u;
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < iterations; ++i)
-                    {
-                        rng[i] = new Unity.Mathematics.Random(1);
-                    }
-
+                    rng = new Random(1);
                     u = (uint*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint>() * iterations, UnsafeUtility.AlignOf<uint>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -46,7 +41,6 @@ public void Init()
 
                 public void Dispose()
                 {
-                    UnsafeUtility.Free(rng, Allocator.Persistent);
                     UnsafeUtility.Free(u, Allocator.Persistent);
                 }
             }
@@ -55,7 +49,7 @@ public static void CommonTestFunction(ref Arguments args)
             {
                 for (int i = 0; i < iterations; ++i)
                 {
-                    args.u[i] = args.rng[i].NextUInt();
+                    args.u[i] = args.rng.NextUInt();
                 }
             }
 
@@ -115,17 +109,12 @@ public unsafe class Random_NextUint2
 
             public struct Arguments : IDisposable
             {
-                public Random* rng;
+                public Random rng;
                 public uint2* u;
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < iterations; ++i)
-                    {
-                        rng[i] = new Unity.Mathematics.Random(1);
-                    }
-
+                    rng = new Random(1);
                     u = (uint2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint2>() * iterations, UnsafeUtility.AlignOf<uint2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -136,7 +125,6 @@ public void Init()
 
                 public void Dispose()
                 {
-                    UnsafeUtility.Free(rng, Allocator.Persistent);
                     UnsafeUtility.Free(u, Allocator.Persistent);
                 }
             }
@@ -145,7 +133,7 @@ public static void CommonTestFunction(ref Arguments args)
             {
                 for (int i = 0; i < iterations; ++i)
                 {
-                    args.u[i] = args.rng[i].NextUInt2();
+                    args.u[i] = args.rng.NextUInt2();
                 }
             }
 
@@ -205,17 +193,12 @@ public unsafe class Random_NextUint3
 
             public struct Arguments : IDisposable
             {
-                public Random* rng;
+                public Random rng;
                 public uint3* u;
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < iterations; ++i)
-                    {
-                        rng[i] = new Unity.Mathematics.Random(1);
-                    }
-
+                    rng = new Random(1);
                     u = (uint3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint3>() * iterations, UnsafeUtility.AlignOf<uint3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -226,7 +209,6 @@ public void Init()
 
                 public void Dispose()
                 {
-                    UnsafeUtility.Free(rng, Allocator.Persistent);
                     UnsafeUtility.Free(u, Allocator.Persistent);
                 }
             }
@@ -235,7 +217,7 @@ public static void CommonTestFunction(ref Arguments args)
             {
                 for (int i = 0; i < iterations; ++i)
                 {
-                    args.u[i] = args.rng[i].NextUInt3();
+                    args.u[i] = args.rng.NextUInt3();
                 }
             }
 
@@ -295,17 +277,12 @@ public unsafe class Random_NextUint4
 
             public struct Arguments : IDisposable
             {
-                public Random* rng;
+                public Random rng;
                 public uint4* u;
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < iterations; ++i)
-                    {
-                        rng[i] = new Unity.Mathematics.Random(1);
-                    }
-
+                    rng = new Random(1);
                     u = (uint4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<uint4>() * iterations, UnsafeUtility.AlignOf<uint4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -316,7 +293,6 @@ public void Init()
 
                 public void Dispose()
                 {
-                    UnsafeUtility.Free(rng, Allocator.Persistent);
                     UnsafeUtility.Free(u, Allocator.Persistent);
                 }
             }
@@ -325,7 +301,7 @@ public static void CommonTestFunction(ref Arguments args)
             {
                 for (int i = 0; i < iterations; ++i)
                 {
-                    args.u[i] = args.rng[i].NextUInt4();
+                    args.u[i] = args.rng.NextUInt4();
                 }
             }
 
@@ -385,17 +361,12 @@ public unsafe class Random_NextFloat
 
             public struct Arguments : IDisposable
             {
-                public Random* rng;
+                public Random rng;
                 public float* f;
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < iterations; ++i)
-                    {
-                        rng[i] = new Unity.Mathematics.Random(1);
-                    }
-
+                    rng = new Random(1);
                     f = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * iterations, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -406,7 +377,6 @@ public void Init()
 
                 public void Dispose()
                 {
-                    UnsafeUtility.Free(rng, Allocator.Persistent);
                     UnsafeUtility.Free(f, Allocator.Persistent);
                 }
             }
@@ -415,7 +385,7 @@ public static void CommonTestFunction(ref Arguments args)
             {
                 for (int i = 0; i < iterations; ++i)
                 {
-                    args.f[i] = args.rng[i].NextFloat();
+                    args.f[i] = args.rng.NextFloat();
                 }
             }
 
@@ -475,17 +445,12 @@ public unsafe class Random_NextFloat2
 
             public struct Arguments : IDisposable
             {
-                public Random* rng;
+                public Random rng;
                 public float2* f;
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < iterations; ++i)
-                    {
-                        rng[i] = new Unity.Mathematics.Random(1);
-                    }
-
+                    rng = new Random(1);
                     f = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -496,7 +461,6 @@ public void Init()
 
                 public void Dispose()
                 {
-                    UnsafeUtility.Free(rng, Allocator.Persistent);
                     UnsafeUtility.Free(f, Allocator.Persistent);
                 }
             }
@@ -505,7 +469,7 @@ public static void CommonTestFunction(ref Arguments args)
             {
                 for (int i = 0; i < iterations; ++i)
                 {
-                    args.f[i] = args.rng[i].NextFloat2();
+                    args.f[i] = args.rng.NextFloat2();
                 }
             }
 
@@ -565,17 +529,12 @@ public unsafe class Random_NextFloat3
 
             public struct Arguments : IDisposable
             {
-                public Random* rng;
+                public Random rng;
                 public float3* f;
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < iterations; ++i)
-                    {
-                        rng[i] = new Unity.Mathematics.Random(1);
-                    }
-
+                    rng = new Random(1);
                     f = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -586,7 +545,6 @@ public void Init()
 
                 public void Dispose()
                 {
-                    UnsafeUtility.Free(rng, Allocator.Persistent);
                     UnsafeUtility.Free(f, Allocator.Persistent);
                 }
             }
@@ -595,7 +553,7 @@ public static void CommonTestFunction(ref Arguments args)
             {
                 for (int i = 0; i < iterations; ++i)
                 {
-                    args.f[i] = args.rng[i].NextFloat3();
+                    args.f[i] = args.rng.NextFloat3();
                 }
             }
 
@@ -655,17 +613,12 @@ public unsafe class Random_NextFloat4
 
             public struct Arguments : IDisposable
             {
-                public Random* rng;
+                public Random rng;
                 public float4* f;
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < iterations; ++i)
-                    {
-                        rng[i] = new Unity.Mathematics.Random(1);
-                    }
-
+                    rng = new Random(1);
                     f = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -676,7 +629,6 @@ public void Init()
 
                 public void Dispose()
                 {
-                    UnsafeUtility.Free(rng, Allocator.Persistent);
                     UnsafeUtility.Free(f, Allocator.Persistent);
                 }
             }
@@ -685,7 +637,7 @@ public static void CommonTestFunction(ref Arguments args)
             {
                 for (int i = 0; i < iterations; ++i)
                 {
-                    args.f[i] = args.rng[i].NextFloat4();
+                    args.f[i] = args.rng.NextFloat4();
                 }
             }
 
@@ -745,17 +697,12 @@ public unsafe class Random_NextDouble
 
             public struct Arguments : IDisposable
             {
-                public Random* rng;
+                public Random rng;
                 public double* f;
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < iterations; ++i)
-                    {
-                        rng[i] = new Unity.Mathematics.Random(1);
-                    }
-
+                    rng = new Random(1);
                     f = (double*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double>() * iterations, UnsafeUtility.AlignOf<double>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -766,7 +713,6 @@ public void Init()
 
                 public void Dispose()
                 {
-                    UnsafeUtility.Free(rng, Allocator.Persistent);
                     UnsafeUtility.Free(f, Allocator.Persistent);
                 }
             }
@@ -775,7 +721,7 @@ public static void CommonTestFunction(ref Arguments args)
             {
                 for (int i = 0; i < iterations; ++i)
                 {
-                    args.f[i] = args.rng[i].NextDouble();
+                    args.f[i] = args.rng.NextDouble();
                 }
             }
 
@@ -835,17 +781,12 @@ public unsafe class Random_NextDouble2
 
             public struct Arguments : IDisposable
             {
-                public Random* rng;
+                public Random rng;
                 public double2* f;
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < iterations; ++i)
-                    {
-                        rng[i] = new Unity.Mathematics.Random(1);
-                    }
-
+                    rng = new Random(1);
                     f = (double2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2>() * iterations, UnsafeUtility.AlignOf<double2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -856,7 +797,6 @@ public void Init()
 
                 public void Dispose()
                 {
-                    UnsafeUtility.Free(rng, Allocator.Persistent);
                     UnsafeUtility.Free(f, Allocator.Persistent);
                 }
             }
@@ -865,7 +805,7 @@ public static void CommonTestFunction(ref Arguments args)
             {
                 for (int i = 0; i < iterations; ++i)
                 {
-                    args.f[i] = args.rng[i].NextDouble2();
+                    args.f[i] = args.rng.NextDouble2();
                 }
             }
 
@@ -925,17 +865,12 @@ public unsafe class Random_NextDouble3
 
             public struct Arguments : IDisposable
             {
-                public Random* rng;
+                public Random rng;
                 public double3* f;
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < iterations; ++i)
-                    {
-                        rng[i] = new Unity.Mathematics.Random(1);
-                    }
-
+                    rng = new Random(1);
                     f = (double3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3>() * iterations, UnsafeUtility.AlignOf<double3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -946,7 +881,6 @@ public void Init()
 
                 public void Dispose()
                 {
-                    UnsafeUtility.Free(rng, Allocator.Persistent);
                     UnsafeUtility.Free(f, Allocator.Persistent);
                 }
             }
@@ -955,7 +889,7 @@ public static void CommonTestFunction(ref Arguments args)
             {
                 for (int i = 0; i < iterations; ++i)
                 {
-                    args.f[i] = args.rng[i].NextDouble3();
+                    args.f[i] = args.rng.NextDouble3();
                 }
             }
 
@@ -1015,17 +949,12 @@ public unsafe class Random_NextDouble4
 
             public struct Arguments : IDisposable
             {
-                public Random* rng;
+                public Random rng;
                 public double4* f;
 
                 public void Init()
                 {
-                    rng = (Random*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<Random>() * iterations, UnsafeUtility.AlignOf<Random>(), Allocator.Persistent);
-                    for (int i = 0; i < iterations; ++i)
-                    {
-                        rng[i] = new Unity.Mathematics.Random(1);
-                    }
-
+                    rng = new Random(1);
                     f = (double4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4>() * iterations, UnsafeUtility.AlignOf<double4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -1036,7 +965,6 @@ public void Init()
 
                 public void Dispose()
                 {
-                    UnsafeUtility.Free(rng, Allocator.Persistent);
                     UnsafeUtility.Free(f, Allocator.Persistent);
                 }
             }
@@ -1045,7 +973,7 @@ public static void CommonTestFunction(ref Arguments args)
             {
                 for (int i = 0; i < iterations; ++i)
                 {
-                    args.f[i] = args.rng[i].NextDouble4();
+                    args.f[i] = args.rng.NextDouble4();
                 }
             }
 
diff --git a/src/Unity.Mathematics.PerformanceTests/TestRotation.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestRotation.gen.cs
index e0324fce..81d0a164 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestRotation.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestRotation.gen.cs
@@ -25,11 +25,13 @@ public unsafe class float4x4_EulerXYZ
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* v;
                 public float4x4* m;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -115,11 +117,13 @@ public unsafe class float3x3_EulerXYZ
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* v;
                 public float3x3* m;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -205,12 +209,14 @@ public unsafe class float4x4_AxisAngle
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* v;
                 public float4x4* m;
                 public float* angle;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -303,12 +309,14 @@ public unsafe class float3x3_AxisAngle
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* v;
                 public float3x3* m;
                 public float* angle;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -401,12 +409,14 @@ public unsafe class float3x3_LookRotation
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* forward;
                 public float3* up;
                 public float3x3* m;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     forward = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -499,12 +509,14 @@ public unsafe class float3x3_LookRotationSafe
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* forward;
                 public float3* up;
                 public float3x3* m;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     forward = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -597,6 +609,7 @@ public unsafe class float4x4_LookAt
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* eye;
                 public float3* target;
                 public float3* up;
@@ -604,6 +617,7 @@ public struct Arguments : IDisposable
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     eye = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
diff --git a/src/Unity.Mathematics.PerformanceTests/TestShuffle.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestShuffle.gen.cs
index 2d0c0a55..03742fd4 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestShuffle.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestShuffle.gen.cs
@@ -25,12 +25,14 @@ public unsafe class float2_shuffle
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2* v1;
                 public float2* v2;
                 public float2* result;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v1 = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -123,12 +125,14 @@ public unsafe class float3_shuffle
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* v1;
                 public float3* v2;
                 public float3* result;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v1 = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -221,12 +225,14 @@ public unsafe class float4_shuffle
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4* v1;
                 public float4* v2;
                 public float4* result;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     v1 = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
diff --git a/src/Unity.Mathematics.PerformanceTests/TestTranspose.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestTranspose.gen.cs
index ff0d0c8a..53198cd8 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestTranspose.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestTranspose.gen.cs
@@ -25,10 +25,12 @@ public unsafe class transpose_float4x4
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4x4* m;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m = (float4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4x4>() * iterations, UnsafeUtility.AlignOf<float4x4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -107,10 +109,12 @@ public unsafe class transpose_float3x3
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3x3* m;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -189,10 +193,12 @@ public unsafe class transpose_float2x2
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2x2* m;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m = (float2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2x2>() * iterations, UnsafeUtility.AlignOf<float2x2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -271,10 +277,12 @@ public unsafe class transpose_double4x4
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public double4x4* m;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m = (double4x4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double4x4>() * iterations, UnsafeUtility.AlignOf<double4x4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -353,10 +361,12 @@ public unsafe class transpose_double3x3
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public double3x3* m;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m = (double3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double3x3>() * iterations, UnsafeUtility.AlignOf<double3x3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -435,10 +445,12 @@ public unsafe class transpose_double2x2
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public double2x2* m;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     m = (double2x2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<double2x2>() * iterations, UnsafeUtility.AlignOf<double2x2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
diff --git a/src/Unity.Mathematics.PerformanceTests/TestTrig.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestTrig.gen.cs
index 4f0ab126..ba2b8ab5 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestTrig.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestTrig.gen.cs
@@ -25,11 +25,13 @@ public unsafe class float_sincos
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float* sin;
                 public float* cos;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     sin = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * iterations, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -115,11 +117,13 @@ public unsafe class float2_sincos
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float2* sin;
                 public float2* cos;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     sin = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -205,11 +209,13 @@ public unsafe class float3_sincos
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float3* sin;
                 public float3* cos;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     sin = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
@@ -295,11 +301,13 @@ public unsafe class float4_sincos
 
             public struct Arguments : IDisposable
             {
+                public Random rng;
                 public float4* sin;
                 public float4* cos;
 
                 public void Init()
                 {
+                    rng = new Random(1);
                     sin = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
                     for (int i = 0; i < iterations; ++i)
                     {
diff --git a/src/Unity.Mathematics/math.cs b/src/Unity.Mathematics/math.cs
index ad464d7d..6a165c0c 100644
--- a/src/Unity.Mathematics/math.cs
+++ b/src/Unity.Mathematics/math.cs
@@ -152,56 +152,97 @@ public enum ShuffleComponent : byte
         /// <param name="x">The uint bits to copy.</param>
         /// <returns>The int with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int asint(uint x) { return (int)x; }
+        public static int asint(uint x)
+        {
+            unsafe
+            {
+                return *(int*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of a uint2 as an int2.</summary>
         /// <param name="x">The uint2 bits to copy.</param>
         /// <returns>The int2 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int2 asint(uint2 x) { return int2((int)x.x, (int)x.y); }
+        public static int2 asint(uint2 x)
+        {
+            unsafe
+            {
+                return *(int2*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of a uint3 as an int3.</summary>
         /// <param name="x">The uint3 bits to copy.</param>
         /// <returns>The int3 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int3 asint(uint3 x) { return int3((int)x.x, (int)x.y, (int)x.z); }
+        public static int3 asint(uint3 x)
+        {
+            unsafe
+            {
+                return *(int3*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of a uint4 as an int4.</summary>
         /// <param name="x">The uint4 bits to copy.</param>
         /// <returns>The int4 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int4 asint(uint4 x) { return int4((int)x.x, (int)x.y, (int)x.z, (int)x.w); }
-
+        public static int4 asint(uint4 x)
+        {
+            unsafe
+            {
+                return *(int4*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of a float as an int.</summary>
         /// <param name="x">The float bits to copy.</param>
         /// <returns>The int with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int asint(float x) {
-            IntFloatUnion u;
-            u.intValue = 0;
-            u.floatValue = x;
-            return u.intValue;
+        public static int asint(float x)
+        {
+            unsafe
+            {
+                return *(int*)&x;
+            }
         }
 
         /// <summary>Returns the bit pattern of a float2 as an int2.</summary>
         /// <param name="x">The float2 bits to copy.</param>
         /// <returns>The int2 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int2 asint(float2 x) { return int2(asint(x.x), asint(x.y)); }
+        public static int2 asint(float2 x)
+        {
+            unsafe
+            {
+                return *(int2*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of a float3 as an int3.</summary>
         /// <param name="x">The float3 bits to copy.</param>
         /// <returns>The int3 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int3 asint(float3 x) { return int3(asint(x.x), asint(x.y), asint(x.z)); }
+        public static int3 asint(float3 x)
+        {
+            unsafe
+            {
+                return *(int3*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of a float4 as an int4.</summary>
         /// <param name="x">The float4 bits to copy.</param>
         /// <returns>The int4 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int4 asint(float4 x) { return int4(asint(x.x), asint(x.y), asint(x.z), asint(x.w)); }
-
+        public static int4 asint(float4 x)
+        {
+            unsafe
+            {
+                return *(int4*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of an int as a uint.</summary>
         /// <param name="x">The int bits to copy.</param>
@@ -213,45 +254,85 @@ public static int asint(float x) {
         /// <param name="x">The int2 bits to copy.</param>
         /// <returns>The uint2 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint2 asuint(int2 x) { return uint2((uint)x.x, (uint)x.y); }
+        public static uint2 asuint(int2 x)
+        {
+            unsafe
+            {
+                return *(uint2*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of an int3 as a uint3.</summary>
         /// <param name="x">The int3 bits to copy.</param>
         /// <returns>The uint3 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint3 asuint(int3 x) { return uint3((uint)x.x, (uint)x.y, (uint)x.z); }
+        public static uint3 asuint(int3 x)
+        {
+            unsafe
+            {
+                return *(uint3*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of an int4 as a uint4.</summary>
         /// <param name="x">The int4 bits to copy.</param>
         /// <returns>The uint4 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint4 asuint(int4 x) { return uint4((uint)x.x, (uint)x.y, (uint)x.z, (uint)x.w); }
-
+        public static uint4 asuint(int4 x)
+        {
+            unsafe
+            {
+                return *(uint4*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of a float as a uint.</summary>
         /// <param name="x">The float bits to copy.</param>
         /// <returns>The uint with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint asuint(float x) { return (uint)asint(x); }
+        public static uint asuint(float x)
+        {
+            unsafe
+            {
+                return *(uint*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of a float2 as a uint2.</summary>
         /// <param name="x">The float2 bits to copy.</param>
         /// <returns>The uint2 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint2 asuint(float2 x) { return uint2(asuint(x.x), asuint(x.y)); }
+        public static uint2 asuint(float2 x)
+        {
+            unsafe
+            {
+                return *(uint2*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of a float3 as a uint3.</summary>
         /// <param name="x">The float3 bits to copy.</param>
         /// <returns>The uint3 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint3 asuint(float3 x) { return uint3(asuint(x.x), asuint(x.y), asuint(x.z)); }
+        public static uint3 asuint(float3 x)
+        {
+            unsafe
+            {
+                return *(uint3*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of a float4 as a uint4.</summary>
         /// <param name="x">The float4 bits to copy.</param>
         /// <returns>The uint4 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint4 asuint(float4 x) { return uint4(asuint(x.x), asuint(x.y), asuint(x.z), asuint(x.w)); }
-
+        public static uint4 asuint(float4 x)
+        {
+            unsafe
+            {
+                return *(uint4*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of a ulong as a long.</summary>
         /// <param name="x">The ulong bits to copy.</param>
@@ -265,13 +346,12 @@ public static int asint(float x) {
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static long aslong(double x)
         {
-            LongDoubleUnion u;
-            u.longValue = 0;
-            u.doubleValue = x;
-            return u.longValue;
+            unsafe
+            {
+                return *(long*)&x;
+            }
         }
 
-
         /// <summary>Returns the bit pattern of a long as a ulong.</summary>
         /// <param name="x">The long bits to copy.</param>
         /// <returns>The ulong with the same bit pattern as the input.</returns>
@@ -282,8 +362,13 @@ public static long aslong(double x)
         /// <param name="x">The double bits to copy.</param>
         /// <returns>The ulong with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ulong asulong(double x) { return (ulong) aslong(x); }
-
+        public static ulong asulong(double x)
+        {
+            unsafe
+            {
+                return *(ulong*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of an int as a float.</summary>
         /// <param name="x">The int bits to copy.</param>
@@ -291,55 +376,95 @@ public static long aslong(double x)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float asfloat(int x)
         {
-            IntFloatUnion u;
-            u.floatValue = 0;
-            u.intValue = x;
-
-            return u.floatValue;
+            unsafe
+            {
+                return *(float*)&x;
+            }
         }
 
         /// <summary>Returns the bit pattern of an int2 as a float2.</summary>
         /// <param name="x">The int2 bits to copy.</param>
         /// <returns>The float2 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 asfloat(int2 x) { return float2(asfloat(x.x), asfloat(x.y)); }
+        public static float2 asfloat(int2 x)
+        {
+            unsafe
+            {
+                return *(float2*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of an int3 as a float3.</summary>
         /// <param name="x">The int3 bits to copy.</param>
         /// <returns>The float3 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 asfloat(int3 x) { return float3(asfloat(x.x), asfloat(x.y), asfloat(x.z)); }
+        public static float3 asfloat(int3 x)
+        {
+            unsafe
+            {
+                return *(float3*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of an int4 as a float4.</summary>
         /// <param name="x">The int4 bits to copy.</param>
         /// <returns>The float4 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 asfloat(int4 x) { return float4(asfloat(x.x), asfloat(x.y), asfloat(x.z), asfloat(x.w)); }
-
+        public static float4 asfloat(int4 x)
+        {
+            unsafe
+            {
+                return *(float4*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of a uint as a float.</summary>
         /// <param name="x">The uint bits to copy.</param>
         /// <returns>The float with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float  asfloat(uint x) { return asfloat((int)x); }
+        public static float asfloat(uint x)
+        {
+            unsafe
+            {
+                return *(float*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of a uint2 as a float2.</summary>
         /// <param name="x">The uint2 bits to copy.</param>
         /// <returns>The float2 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 asfloat(uint2 x) { return float2(asfloat(x.x), asfloat(x.y)); }
+        public static float2 asfloat(uint2 x)
+        {
+            unsafe
+            {
+                return *(float2*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of a uint3 as a float3.</summary>
         /// <param name="x">The uint3 bits to copy.</param>
         /// <returns>The float3 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 asfloat(uint3 x) { return float3(asfloat(x.x), asfloat(x.y), asfloat(x.z)); }
+        public static float3 asfloat(uint3 x)
+        {
+            unsafe
+            {
+                return *(float3*)&x;
+            }
+        }
 
         /// <summary>Returns the bit pattern of a uint4 as a float4.</summary>
         /// <param name="x">The uint4 bits to copy.</param>
         /// <returns>The float4 with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 asfloat(uint4 x) { return float4(asfloat(x.x), asfloat(x.y), asfloat(x.z), asfloat(x.w)); }
+        public static float4 asfloat(uint4 x)
+        {
+            unsafe
+            {
+                return *(float4*)&x;
+            }
+        }
 
         /// <summary>
         /// Returns a bitmask representation of a bool4. Storing one 1 bit per component
@@ -368,19 +493,23 @@ public static int bitmask(bool4 value)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static double asdouble(long x)
         {
-            LongDoubleUnion u;
-            u.doubleValue = 0;
-            u.longValue = x;
-            return u.doubleValue;
+            unsafe
+            {
+                return *(double*)&x;
+            }
         }
 
-
         /// <summary>Returns the bit pattern of a ulong as a double.</summary>
         /// <param name="x">The ulong bits to copy.</param>
         /// <returns>The double with the same bit pattern as the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double asdouble(ulong x) { return asdouble((long)x); }
-
+        public static double asdouble(ulong x)
+        {
+            unsafe
+            {
+                return *(double*)&x;
+            }
+        }
 
         /// <summary>Returns true if the input float is a finite floating point value, false otherwise.</summary>
         /// <param name="x">The float value to test.</param>
@@ -6647,15 +6776,6 @@ internal static double4 movehl(double4 a, double4 b)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static uint4 fold_to_uint(double4 x) { return uint4(fold_to_uint(x.x), fold_to_uint(x.y), fold_to_uint(x.z), fold_to_uint(x.w)); }
 
-        [StructLayout(LayoutKind.Explicit)]
-        internal struct IntFloatUnion
-        {
-            [FieldOffset(0)]
-            public int intValue;
-            [FieldOffset(0)]
-            public float floatValue;
-        }
-
         [StructLayout(LayoutKind.Explicit)]
         internal struct LongDoubleUnion
         {

From 6ffb4b701ed991f6fe27aaf7d7ea3a5dafec14ab Mon Sep 17 00:00:00 2001
From: olivierd <olivierd@unity3d.com>
Date: Fri, 17 Dec 2021 17:53:25 -0500
Subject: [PATCH 12/94] Quaternion to Euler conversion functions (#201)

DOTS-984, DOTS-2396

Co-authored-by: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Co-authored-by: Jo Petty <49957016+jo-unity@users.noreply.github.com>
---
 src/CHANGELOG.md                              |  10 +-
 src/Tests/Tests/Shared/TestMath.cs            | 240 +++++++++
 src/Tests/Tests/Shared/TestQuaternion.cs      |  38 +-
 .../VectorGenerator.cs                        |  35 ++
 .../TestMath.gen.cs                           | 500 ++++++++++++++++++
 src/Unity.Mathematics/math.cs                 | 310 +++++++++++
 src/Unity.Mathematics/quaternion.cs           |  19 +-
 7 files changed, 1141 insertions(+), 11 deletions(-)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index b86d2ff8..9ca6b8dd 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -2,11 +2,15 @@
 
 ## [Unreleased]
 ### Added
-* Added `math.square()` to compute the square (x * x).
-* Added `math.orthonormal_basis()` to compute an orthonormal basis from a single unit length vector.
-* Added `math.sign(x)` for int, int2, int3 and int4.
+* Added `math.square` to compute the square (x * x).
+* Added `math.orthonormal_basis` to compute an orthonormal basis from a single unit length vector.
+* Added `math.sign` for int, int2, int3 and int4.
+* Added `math.chgsign` for float, float2, float3, and float4.
+* Added `math.Euler` to convert a quaternion to Euler angles.
+* Added `math.angle` to compute the angle between two unit quaternions.
 ### Changed
 * `asfloat(uint)`, `asuint(float)`, `asint(float)` and other related methods are now faster in mono without Burst. Other methods which use these will see a performance improvement.
+* Modified `quaternion.nlerp` to be branchless.
 ### Deprecated
 ### Removed
 ### Fixed
diff --git a/src/Tests/Tests/Shared/TestMath.cs b/src/Tests/Tests/Shared/TestMath.cs
index ffe458f6..ee655b8a 100644
--- a/src/Tests/Tests/Shared/TestMath.cs
+++ b/src/Tests/Tests/Shared/TestMath.cs
@@ -3838,5 +3838,245 @@ public static void orthonormal_basis_double()
                 TestUtils.IsTrue(OrthonormalBasisSquaredError(v1, v2, v3) < kOrthonormalBasisSqErrorTolerance);
             }
         }
+
+        [TestCompiler]
+        public static void chgsign_float()
+        {
+            float c = chgsign(1f, -1f);
+            TestUtils.AreEqual(-1f, c);
+
+            c = chgsign(1f, 1f);
+            TestUtils.AreEqual(1f, c);
+
+            c = chgsign(-1f, -1f);
+            TestUtils.AreEqual(1f, c);
+
+            c = chgsign(-1f, 1f);
+            TestUtils.AreEqual(-1f, c);
+
+            c = chgsign(-1f, 0f);
+            TestUtils.AreEqual(-1f, c);
+
+            c = chgsign(-1f, -0f);
+            TestUtils.AreEqual(1f, c);
+
+            c = chgsign(1f, TestUtils.SignedFloatQNaN());
+            TestUtils.AreEqual(-1f, c);
+
+            c = chgsign(-1f, TestUtils.SignedFloatQNaN());
+            TestUtils.AreEqual(1f, c);
+
+            c = chgsign(1f, TestUtils.UnsignedFloatQNaN());
+            TestUtils.AreEqual(1f, c);
+
+            c = chgsign(-1f, TestUtils.UnsignedFloatQNaN());
+            TestUtils.AreEqual(-1f, c);
+
+            c = chgsign(1f, INFINITY);
+            TestUtils.AreEqual(1f, c);
+
+            c = chgsign(-1f, INFINITY);
+            TestUtils.AreEqual(-1f, c);
+
+            c = chgsign(1f, -INFINITY);
+            TestUtils.AreEqual(-1f, c);
+
+            c = chgsign(-1f, -INFINITY);
+            TestUtils.AreEqual(1f, c);
+
+            c = chgsign(TestUtils.UnsignedFloatQNaN(), 1f);
+            TestUtils.IsTrue(isnan(c));
+            TestUtils.AreEqual(asuint(TestUtils.UnsignedFloatQNaN()), asuint(c));
+
+            c = chgsign(TestUtils.UnsignedFloatQNaN(), -1f);
+            TestUtils.IsTrue(isnan(c));
+            TestUtils.AreEqual(asuint(TestUtils.SignedFloatQNaN()), asuint(c));
+
+            c = chgsign(0f, 1f);
+            TestUtils.AreEqual(0f, c);
+            TestUtils.AreEqual(0u, asuint(c));
+
+            c = chgsign(0f, -1f);
+            TestUtils.AreEqual(0f, c);
+            TestUtils.AreEqual(asuint(TestUtils.SignedFloatZero()), asuint(c));
+        }
+
+        [TestCompiler]
+        public static void chgsign_float2()
+        {
+            float2 c = chgsign(float2(1f, -2f), float2(-1f, 23.548f));
+            TestUtils.AreEqual(float2(-1f, -2f), c);
+
+            c = chgsign(float2(-1f), float2(-1f, 1f));
+            TestUtils.AreEqual(float2(1f, -1f), c);
+
+            c = chgsign(float2(-1f), float2(1f, -1f));
+            TestUtils.AreEqual(float2(-1f, 1f), c);
+
+            c = chgsign(float2(-1f), float2(TestUtils.SignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()));
+            TestUtils.AreEqual(float2(1f, -1f), c);
+
+            c = chgsign(float2(-1f), float2(TestUtils.UnsignedFloatQNaN(), TestUtils.SignedFloatQNaN()));
+            TestUtils.AreEqual(float2(-1f, 1f), c);
+
+            c = chgsign(float2(TestUtils.SignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()), float2(-1f, 1f));
+            TestUtils.IsTrue(all(isnan(c)));
+            TestUtils.AreEqual(asuint(float2(TestUtils.UnsignedFloatQNaN())), asuint(c));
+
+            c = chgsign(float2(TestUtils.SignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()), float2(1f, -1f));
+            TestUtils.IsTrue(all(isnan(c)));
+            TestUtils.AreEqual(asuint(float2(TestUtils.SignedFloatQNaN())), asuint(c));
+
+            c = chgsign(float2(TestUtils.SignedFloatZero(), 0f), float2(TestUtils.SignedFloatZero(), 0f));
+            TestUtils.AreEqual(float2.zero, c);
+            TestUtils.AreEqual(uint2.zero, asuint(c));
+
+            c = chgsign(float2(TestUtils.SignedFloatZero(), 0f), float2(0f, TestUtils.SignedFloatZero()));
+            TestUtils.AreEqual(float2.zero, c);
+            TestUtils.AreEqual(asuint(math.float2(TestUtils.SignedFloatZero())), asuint(c));
+        }
+
+        [TestCompiler]
+        public static void chgsign_float3()
+        {
+            float3 c = chgsign(float3(1f, -2f, 3f), float3(-1f, 23.548f, -0f));
+            TestUtils.AreEqual(float3(-1f, -2f, -3f), c);
+
+            c = chgsign(float3(-1f), float3(-1f, 1f, -1f));
+            TestUtils.AreEqual(float3(1f, -1f, 1f), c);
+
+            c = chgsign(float3(-1f), float3(1f, -1f, 1f));
+            TestUtils.AreEqual(float3(-1f, 1f, -1f), c);
+
+            c = chgsign(float3(-1f), float3(TestUtils.SignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.SignedFloatQNaN()));
+            TestUtils.AreEqual(float3(1f, -1f, 1f), c);
+
+            c = chgsign(float3(-1f), float3(TestUtils.UnsignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()));
+            TestUtils.AreEqual(float3(-1f, 1f, -1f), c);
+
+            c = chgsign(float3(TestUtils.SignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(-1f, 1f, -1f));
+            TestUtils.IsTrue(all(isnan(c)));
+            TestUtils.AreEqual(asuint(float3(TestUtils.UnsignedFloatQNaN())), asuint(c));
+
+            c = chgsign(float3(TestUtils.SignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(1f, -1f, 1f));
+            TestUtils.IsTrue(all(isnan(c)));
+            TestUtils.AreEqual(asuint(float3(TestUtils.SignedFloatQNaN())), asuint(c));
+
+            c = chgsign(float3(TestUtils.SignedFloatZero(), 0f, TestUtils.SignedFloatZero()), float3(TestUtils.SignedFloatZero(), 0f, TestUtils.SignedFloatZero()));
+            TestUtils.AreEqual(float3.zero, c);
+            TestUtils.AreEqual(uint3.zero, asuint(c));
+
+            c = chgsign(float3(TestUtils.SignedFloatZero(), 0f, TestUtils.SignedFloatZero()), float3(0f, TestUtils.SignedFloatZero(), 0f));
+            TestUtils.AreEqual(float3.zero, c);
+            TestUtils.AreEqual(asuint(math.float3(TestUtils.SignedFloatZero())), asuint(c));
+        }
+
+        [TestCompiler]
+        public static void chgsign_float4()
+        {
+            float4 c = chgsign(float4(1f, 2f, 3f, -4f), float4(-1f, 0f, -0f, -23.56f));
+            TestUtils.AreEqual(float4(-1f, 2f, -3f, 4f), c);
+
+            c = chgsign(float4(-1f), float4(-1f, 1f, -1f, 1f));
+            TestUtils.AreEqual(float4(1f, -1f, 1f, -1f), c);
+
+            c = chgsign(float4(-1f), float4(1f, -1f, 1f, -1f));
+            TestUtils.AreEqual(float4(-1f, 1f, -1f, 1f), c);
+
+            c = chgsign(float4(-1f), float4(TestUtils.SignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()));
+            TestUtils.AreEqual(float4(1f, -1f, 1f, -1f), c);
+
+            c = chgsign(float4(-1f), float4(TestUtils.UnsignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.SignedFloatQNaN()));
+            TestUtils.AreEqual(float4(-1f, 1f, -1f, 1f), c);
+
+            c = chgsign(float4(TestUtils.SignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()), float4(-1f, 1f, -1f, 1f));
+            TestUtils.IsTrue(all(isnan(c)));
+            TestUtils.AreEqual(asuint(float4(TestUtils.UnsignedFloatQNaN())), asuint(c));
+
+            c = chgsign(float4(TestUtils.SignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.UnsignedFloatQNaN()), float4(1f, -1f, 1f, -1f));
+            TestUtils.IsTrue(all(isnan(c)));
+            TestUtils.AreEqual(asuint(float4(TestUtils.SignedFloatQNaN())), asuint(c));
+
+            c = chgsign(float4(TestUtils.SignedFloatZero(), 0f, TestUtils.SignedFloatZero(), 0f), float4(TestUtils.SignedFloatZero(), 0f, TestUtils.SignedFloatZero(), 0f));
+            TestUtils.AreEqual(float4.zero, c);
+            TestUtils.AreEqual(uint4.zero, asuint(c));
+
+            c = chgsign(float4(TestUtils.SignedFloatZero(), 0f, TestUtils.SignedFloatZero(), 0f), float4(0f, TestUtils.SignedFloatZero(), 0f, TestUtils.SignedFloatZero()));
+            TestUtils.AreEqual(float4.zero, c);
+            TestUtils.AreEqual(asuint(math.float4(TestUtils.SignedFloatZero())), asuint(c));
+        }
+
+        [TestCompiler]
+        public static unsafe void quaternion_to_euler()
+        {
+            const float epsilon = 0.0045f;
+            const float PI_div_6 = PI / 6f;
+            const int testAngleCount = 13 * 13 * 13 * 20;
+
+            float3* testAngles = stackalloc float3[testAngleCount];
+
+            int idx = 0;
+            for (int i = 0; i < 13; ++i)
+            {
+                float x = -PI + i * PI;
+                for (int j = 0; j < 13; ++j)
+                {
+                    float y = -PI + j * PI_div_6;
+                    for (int k = 0; k < 13; ++k)
+                    {
+                        float z = -PI + k * PI_div_6;
+                        for (int l = 0; l < 20; ++l)
+                        {
+                            testAngles[idx++] = float3(x, y, z) * (0.99f + l * 0.001f);
+                        }
+                    }
+                }
+            }
+
+            for (int order = 0; order < 6; ++order)
+            {
+                for (int i = 0; i < testAngleCount; ++i)
+                {
+                    // We cannot directly compare Euler angles, as different angles may represent the same rotation,
+                    // so we have to transform them back to quats to test.
+                    // We also need to create our initial test quaternion, as what we generated was euler angles.
+                    quaternion expected = TestRefEulerToQuat(testAngles[i], math.RotationOrder.Default);
+
+                    float3 actualEulers = Euler(expected, (math.RotationOrder)order);
+                    quaternion actualQuat = TestRefEulerToQuat(actualEulers, (math.RotationOrder)order);
+
+                    float error = angle(expected, actualQuat);
+                    TestUtils.AreEqual(0f, error, epsilon);
+                }
+            }
+        }
+
+        static quaternion TestRefEulerToQuat(float3 angle, math.RotationOrder order)
+        {
+            float3 halfRot = angle * 0.5f;
+            sincos(halfRot, out float3 s, out float3 c);
+
+            quaternion qX = quaternion(s.x, 0f, 0f, c.x);
+            quaternion qY = quaternion(0f, s.y, 0f, c.y);
+            quaternion qZ = quaternion(0f, 0f, s.z, c.z);
+
+            switch (order)
+            {
+                case math.RotationOrder.XYZ:
+                    return mul(mul(qZ, qY), qX);
+                case math.RotationOrder.XZY:
+                    return mul(mul(qY, qZ), qX);
+                case math.RotationOrder.YXZ:
+                    return mul(mul(qZ, qX), qY);
+                case math.RotationOrder.YZX:
+                    return mul(mul(qX, qZ), qY);
+                case math.RotationOrder.ZXY:
+                    return mul(mul(qY, qX), qZ);
+                case math.RotationOrder.ZYX:
+                    return mul(mul(qX, qY), qZ);
+                default:
+                    return quaternion(float4(1f));
+            }
+        }
     }
 }
diff --git a/src/Tests/Tests/Shared/TestQuaternion.cs b/src/Tests/Tests/Shared/TestQuaternion.cs
index 9bd5ebf6..5f531b0e 100644
--- a/src/Tests/Tests/Shared/TestQuaternion.cs
+++ b/src/Tests/Tests/Shared/TestQuaternion.cs
@@ -89,7 +89,7 @@ public static void quaternion_axis_angle_consistency()
         }
 
         [TestCompiler]
-        public static void quaternion_euler()
+        public static void euler_to_quaternion()
         {
             float3 test_angles = TestMatrix.test_angles;
             quaternion q0 = quaternion.Euler(test_angles);
@@ -344,5 +344,41 @@ public static void quaternion_EqualsObjectOverride()
             TestUtils.IsFalse(new quaternion().Equals((object) new int()));
             TestUtils.IsTrue(new quaternion().Equals((object) new quaternion()));
         }
+
+        [TestCase]
+        public static void quaternion_angle()
+        {
+            // Test variations of angles
+            for (int i = 0; i < 18; ++i)
+            {
+                for (int j = 0; j < 18; ++j)
+                {
+                    float angle1 = radians(i * 10f);
+                    float angle2 = radians(j * 10f);
+
+                    quaternion q1 = quaternion.Euler(0f, angle1, 0f);
+                    quaternion q2 = quaternion.Euler(0f, angle2, 0f);
+                    TestUtils.AreEqual(abs(angle2 - angle1), math.angle(q1, q2), 1e-5f);
+                }
+            }
+
+            quaternion q = quaternion.identity;
+            float angle = math.angle(q, q);
+            TestUtils.AreEqual(0f, angle);
+
+            quaternion nq = -q.value;
+            angle = math.angle(q, nq);
+            TestUtils.AreEqual(0f, angle);
+
+            // Nearly normalized quaternion to self is zero
+            q = new quaternion(0.6244676f, -0.7761726f, -0.06790633f, -0.05463386f); // dot(q, q) = 0.999999816753
+            angle = math.angle(q, q);
+            TestUtils.AreEqual(0f, angle);
+
+            // Nearly normalized quaternion to negative self is zero
+            nq = -q.value; // dot(q, nq) = -0.999999816753
+            angle = math.angle(q, nq);
+            TestUtils.AreEqual(0f, angle);
+        }
     }
 }
diff --git a/src/Unity.Mathematics.CodeGen/VectorGenerator.cs b/src/Unity.Mathematics.CodeGen/VectorGenerator.cs
index 1a696c16..87f7fbb0 100644
--- a/src/Unity.Mathematics.CodeGen/VectorGenerator.cs
+++ b/src/Unity.Mathematics.CodeGen/VectorGenerator.cs
@@ -3859,6 +3859,41 @@ public void GenerateMathPerformanceTests(StringBuilder str)
                 new PerformanceTestArrayArgument { m_ElementType = "uint4", m_MemberName = "v", m_ElementInitializer = "rng.NextUInt4()" },
             }, "args.result[i] = math.asint(args.v[i]);", 400000);
 
+            GeneratePerformanceTest(str, "chgsign_float", new PerformanceTestArrayArgument[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "float", m_MemberName = "f", m_ElementInitializer = "1.0f" },
+                new PerformanceTestArrayArgument { m_ElementType = "float", m_MemberName = "sign", m_ElementInitializer = "rng.NextFloat(-1.0f, 1.0f)" },
+                new PerformanceTestArrayArgument { m_ElementType = "float", m_MemberName = "result", m_ElementInitializer = "0.0f" },
+            }, "args.result[i] = math.chgsign(args.f[i], args.sign[i]);", 100000);
+
+            GeneratePerformanceTest(str, "chgsign_float2", new PerformanceTestArrayArgument[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "float2", m_MemberName = "f", m_ElementInitializer = "new float2(1.0f)" },
+                new PerformanceTestArrayArgument { m_ElementType = "float2", m_MemberName = "sign", m_ElementInitializer = "rng.NextFloat2(-1.0f, 1.0f)" },
+                new PerformanceTestArrayArgument { m_ElementType = "float2", m_MemberName = "result", m_ElementInitializer = "new float2()" },
+            }, "args.result[i] = math.chgsign(args.f[i], args.sign[i]);", 100000);
+
+            GeneratePerformanceTest(str, "chgsign_float3", new PerformanceTestArrayArgument[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "float3", m_MemberName = "f", m_ElementInitializer = "new float3(1.0f)" },
+                new PerformanceTestArrayArgument { m_ElementType = "float3", m_MemberName = "sign", m_ElementInitializer = "rng.NextFloat3(-1.0f, 1.0f)" },
+                new PerformanceTestArrayArgument { m_ElementType = "float3", m_MemberName = "result", m_ElementInitializer = "new float3()" },
+            }, "args.result[i] = math.chgsign(args.f[i], args.sign[i]);", 100000);
+
+            GeneratePerformanceTest(str, "chgsign_float4", new PerformanceTestArrayArgument[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "float4", m_MemberName = "f", m_ElementInitializer = "new float4(1.0f)" },
+                new PerformanceTestArrayArgument { m_ElementType = "float4", m_MemberName = "sign", m_ElementInitializer = "rng.NextFloat4(-1.0f, 1.0f)" },
+                new PerformanceTestArrayArgument { m_ElementType = "float4", m_MemberName = "result", m_ElementInitializer = "new float4()" },
+            }, "args.result[i] = math.chgsign(args.f[i], args.sign[i]);", 100000);
+
+            GeneratePerformanceTest(str, "angle_quaternion_quaternion", new PerformanceTestArrayArgument[]
+            {
+                new PerformanceTestArrayArgument { m_ElementType = "quaternion", m_MemberName = "q1", m_ElementInitializer = "rng.NextQuaternionRotation()" },
+                new PerformanceTestArrayArgument { m_ElementType = "quaternion", m_MemberName = "q2", m_ElementInitializer = "rng.NextQuaternionRotation()" },
+                new PerformanceTestArrayArgument { m_ElementType = "float", m_MemberName = "result", m_ElementInitializer = "new float()" },
+            }, "args.result[i] = math.angle(args.q1[i], args.q2[i]);", 10000);
+
             EndPerformanceTestCodeGen(str);
         }
 
diff --git a/src/Unity.Mathematics.PerformanceTests/TestMath.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestMath.gen.cs
index d6ad87f5..dfab18d9 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestMath.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestMath.gen.cs
@@ -2784,6 +2784,506 @@ public void asint_uint4_burst()
             var args = new asint_uint4.Arguments();
             args.Init();
 
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class chgsign_float
+        {
+            public const int iterations = 100000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public float* f;
+                public float* sign;
+                public float* result;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    f = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * iterations, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        f[i] = 1.0f;
+                    }
+
+                    sign = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * iterations, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        sign[i] = rng.NextFloat(-1.0f, 1.0f);
+                    }
+
+                    result = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * iterations, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = 0.0f;
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(f, Allocator.Persistent);
+                    UnsafeUtility.Free(sign, Allocator.Persistent);
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.chgsign(args.f[i], args.sign[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void chgsign_float_mono()
+        {
+            chgsign_float.TestFunction testFunction = chgsign_float.MonoTestFunction;
+            var args = new chgsign_float.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void chgsign_float_burst()
+        {
+            FunctionPointer<chgsign_float.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<chgsign_float.TestFunction>(chgsign_float.BurstTestFunction);
+            var args = new chgsign_float.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class chgsign_float2
+        {
+            public const int iterations = 100000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public float2* f;
+                public float2* sign;
+                public float2* result;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    f = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        f[i] = new float2(1.0f);
+                    }
+
+                    sign = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        sign[i] = rng.NextFloat2(-1.0f, 1.0f);
+                    }
+
+                    result = (float2*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float2>() * iterations, UnsafeUtility.AlignOf<float2>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new float2();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(f, Allocator.Persistent);
+                    UnsafeUtility.Free(sign, Allocator.Persistent);
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.chgsign(args.f[i], args.sign[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void chgsign_float2_mono()
+        {
+            chgsign_float2.TestFunction testFunction = chgsign_float2.MonoTestFunction;
+            var args = new chgsign_float2.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void chgsign_float2_burst()
+        {
+            FunctionPointer<chgsign_float2.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<chgsign_float2.TestFunction>(chgsign_float2.BurstTestFunction);
+            var args = new chgsign_float2.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class chgsign_float3
+        {
+            public const int iterations = 100000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public float3* f;
+                public float3* sign;
+                public float3* result;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    f = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        f[i] = new float3(1.0f);
+                    }
+
+                    sign = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        sign[i] = rng.NextFloat3(-1.0f, 1.0f);
+                    }
+
+                    result = (float3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3>() * iterations, UnsafeUtility.AlignOf<float3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new float3();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(f, Allocator.Persistent);
+                    UnsafeUtility.Free(sign, Allocator.Persistent);
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.chgsign(args.f[i], args.sign[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void chgsign_float3_mono()
+        {
+            chgsign_float3.TestFunction testFunction = chgsign_float3.MonoTestFunction;
+            var args = new chgsign_float3.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void chgsign_float3_burst()
+        {
+            FunctionPointer<chgsign_float3.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<chgsign_float3.TestFunction>(chgsign_float3.BurstTestFunction);
+            var args = new chgsign_float3.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class chgsign_float4
+        {
+            public const int iterations = 100000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public float4* f;
+                public float4* sign;
+                public float4* result;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    f = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        f[i] = new float4(1.0f);
+                    }
+
+                    sign = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        sign[i] = rng.NextFloat4(-1.0f, 1.0f);
+                    }
+
+                    result = (float4*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float4>() * iterations, UnsafeUtility.AlignOf<float4>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new float4();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(f, Allocator.Persistent);
+                    UnsafeUtility.Free(sign, Allocator.Persistent);
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.chgsign(args.f[i], args.sign[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void chgsign_float4_mono()
+        {
+            chgsign_float4.TestFunction testFunction = chgsign_float4.MonoTestFunction;
+            var args = new chgsign_float4.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void chgsign_float4_burst()
+        {
+            FunctionPointer<chgsign_float4.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<chgsign_float4.TestFunction>(chgsign_float4.BurstTestFunction);
+            var args = new chgsign_float4.Arguments();
+            args.Init();
+
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class angle_quaternion_quaternion
+        {
+            public const int iterations = 10000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public quaternion* q1;
+                public quaternion* q2;
+                public float* result;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    q1 = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        q1[i] = rng.NextQuaternionRotation();
+                    }
+
+                    q2 = (quaternion*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<quaternion>() * iterations, UnsafeUtility.AlignOf<quaternion>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        q2[i] = rng.NextQuaternionRotation();
+                    }
+
+                    result = (float*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float>() * iterations, UnsafeUtility.AlignOf<float>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        result[i] = new float();
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(q1, Allocator.Persistent);
+                    UnsafeUtility.Free(q2, Allocator.Persistent);
+                    UnsafeUtility.Free(result, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.result[i] = math.angle(args.q1[i], args.q2[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void angle_quaternion_quaternion_mono()
+        {
+            angle_quaternion_quaternion.TestFunction testFunction = angle_quaternion_quaternion.MonoTestFunction;
+            var args = new angle_quaternion_quaternion.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void angle_quaternion_quaternion_burst()
+        {
+            FunctionPointer<angle_quaternion_quaternion.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<angle_quaternion_quaternion.TestFunction>(angle_quaternion_quaternion.BurstTestFunction);
+            var args = new angle_quaternion_quaternion.Arguments();
+            args.Init();
+
             var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
             {
                 testFunction.Invoke(ref args);
diff --git a/src/Unity.Mathematics/math.cs b/src/Unity.Mathematics/math.cs
index 6a165c0c..016cc971 100644
--- a/src/Unity.Mathematics/math.cs
+++ b/src/Unity.Mathematics/math.cs
@@ -6600,6 +6600,46 @@ public static void orthonormal_basis(double3 normal, out double3 basis1, out dou
             basis2.z = -normal.y;
         }
 
+        /// <summary>Change the sign of x based on the most significant bit of y [msb(y) ? -x : x].</summary>
+        /// <param name="x">The single precision float to change the sign.</param>
+        /// <param name="y">The single precision float used to test the most significant bit.</param>
+        /// <returns>Returns x with changed sign based on y.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float chgsign(float x, float y)
+        {
+            return asfloat(asuint(x) ^ (asuint(y) & 0x80000000));
+        }
+
+        /// <summary>Change the sign of components of x based on the most significant bit of components of y [msb(y) ? -x : x].</summary>
+        /// <param name="x">The single precision float vector to change the sign.</param>
+        /// <param name="y">The single precision float vector used to test the most significant bit.</param>
+        /// <returns>Returns vector x with changed sign based on vector y.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float2 chgsign(float2 x, float2 y)
+        {
+            return asfloat(asuint(x) ^ (asuint(y) & 0x80000000));
+        }
+
+        /// <summary>Change the sign of components of x based on the most significant bit of components of y [msb(y) ? -x : x].</summary>
+        /// <param name="x">The single precision float vector to change the sign.</param>
+        /// <param name="y">The single precision float vector used to test the most significant bit.</param>
+        /// <returns>Returns vector x with changed sign based on vector y.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3 chgsign(float3 x, float3 y)
+        {
+            return asfloat(asuint(x) ^ (asuint(y) & 0x80000000));
+        }
+
+        /// <summary>Change the sign of components of x based on the most significant bit of components of y [msb(y) ? -x : x].</summary>
+        /// <param name="x">The single precision float vector to change the sign.</param>
+        /// <param name="y">The single precision float vector used to test the most significant bit.</param>
+        /// <returns>Returns vector x with changed sign based on vector y.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float4 chgsign(float4 x, float4 y)
+        {
+            return asfloat(asuint(x) ^ (asuint(y) & 0x80000000));
+        }
+
         /// <summary>Returns a uint hash from a block of memory using the xxhash32 algorithm. Can only be used in an unsafe context.</summary>
         /// <param name="pBuffer">A pointer to the beginning of the data.</param>
         /// <param name="numBytes">Number of bytes to hash.</param>
@@ -6706,6 +6746,276 @@ public static unsafe uint hash(void* pBuffer, int numBytes, uint seed = 0)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float3 right() { return new float3(1.0f, 0.0f, 0.0f); }
 
+        /// <summary>
+        /// Returns the Euler angle representation of the quaternion following the XYZ rotation order.
+        /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin.
+        /// </summary>
+        /// <param name="q">The quaternion to convert to Euler angles.</param>
+        /// <returns>The Euler angle representation of the quaternion in XYZ order.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3 EulerXYZ(quaternion q)
+        {
+            const float epsilon = 1e-6f;
+            const float cutoff = (1f - 2f * epsilon) * (1f - 2f * epsilon);
+
+            // prepare the data
+            var qv = q.value;
+            var d1 = qv * qv.wwww * float4(2f); //xw, yw, zw, ww
+            var d2 = qv * qv.yzxw * float4(2f); //xy, yz, zx, ww
+            var d3 = qv * qv;
+            var euler = Unity.Mathematics.float3.zero;
+
+            var y1 = d2.z - d1.y;
+            if (y1 * y1 < cutoff)
+            {
+                var x1 = d2.y + d1.x;
+                var x2 = d3.z + d3.w - d3.y - d3.x;
+                var z1 = d2.x + d1.z;
+                var z2 = d3.x + d3.w - d3.y - d3.z;
+                euler = float3(atan2(x1, x2), -asin(y1), atan2(z1, z2));
+            }
+            else //xzx
+            {
+                y1 = clamp(y1, -1f, 1f);
+                var abcd = float4(d2.z, d1.y, d2.x, d1.z);
+                var x1 = 2f * (abcd.x * abcd.w + abcd.y * abcd.z); //2(ad+bc)
+                var x2 = csum(abcd * abcd * float4(-1f, 1f, -1f, 1f));
+                euler = float3(atan2(x1, x2), -asin(y1), 0f);
+            }
+
+            return euler;
+        }
+
+        /// <summary>
+        /// Returns the Euler angle representation of the quaternion following the XZY rotation order.
+        /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin.
+        /// </summary>
+        /// <param name="q">The quaternion to convert to Euler angles.</param>
+        /// <returns>The Euler angle representation of the quaternion in XZY order.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3 EulerXZY(quaternion q)
+        {
+            const float epsilon = 1e-6f;
+            const float cutoff = (1f - 2f * epsilon) * (1f - 2f * epsilon);
+
+            // prepare the data
+            var qv = q.value;
+            var d1 = qv * qv.wwww * float4(2f); //xw, yw, zw, ww
+            var d2 = qv * qv.yzxw * float4(2f); //xy, yz, zx, ww
+            var d3 = qv * qv;
+            var euler = Unity.Mathematics.float3.zero;
+
+            var y1 = d2.x + d1.z;
+            if (y1 * y1 < cutoff)
+            {
+                var x1 = -d2.y + d1.x;
+                var x2 = d3.y + d3.w - d3.z - d3.x;
+                var z1 = -d2.z + d1.y;
+                var z2 = d3.x + d3.w - d3.y - d3.z;
+                euler = float3(atan2(x1, x2), asin(y1), atan2(z1, z2));
+            }
+            else //xyx
+            {
+                y1 = clamp(y1, -1f, 1f);
+                var abcd = float4(d2.x, d1.z, d2.z, d1.y);
+                var x1 = 2f * (abcd.x * abcd.w + abcd.y * abcd.z); //2(ad+bc)
+                var x2 = csum(abcd * abcd * float4(-1f, 1f, -1f, 1f));
+                euler = float3(atan2(x1, x2), asin(y1), 0f);
+            }
+
+            return euler.xzy;
+        }
+
+        /// <summary>
+        /// Returns the Euler angle representation of the quaternion following the YXZ rotation order.
+        /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin.
+        /// </summary>
+        /// <param name="q">The quaternion to convert to Euler angles.</param>
+        /// <returns>The Euler angle representation of the quaternion in YXZ order.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3 EulerYXZ(quaternion q)
+        {
+            const float epsilon = 1e-6f;
+            const float cutoff = (1f - 2f * epsilon) * (1f - 2f * epsilon);
+
+            // prepare the data
+            var qv = q.value;
+            var d1 = qv * qv.wwww * float4(2f); //xw, yw, zw, ww
+            var d2 = qv * qv.yzxw * float4(2f); //xy, yz, zx, ww
+            var d3 = qv * qv;
+            var euler = Unity.Mathematics.float3.zero;
+
+            var y1 = d2.y + d1.x;
+            if (y1 * y1 < cutoff)
+            {
+                var x1 = -d2.z + d1.y;
+                var x2 = d3.z + d3.w - d3.x - d3.y;
+                var z1 = -d2.x + d1.z;
+                var z2 = d3.y + d3.w - d3.z - d3.x;
+                euler = float3(atan2(x1, x2), asin(y1), atan2(z1, z2));
+            }
+            else //yzy
+            {
+                y1 = clamp(y1, -1f, 1f);
+                var abcd = float4(d2.x, d1.z, d2.y, d1.x);
+                var x1 = 2f * (abcd.x * abcd.w + abcd.y * abcd.z); //2(ad+bc)
+                var x2 = csum(abcd * abcd * float4(-1f, 1f, -1f, 1f));
+                euler = float3(atan2(x1, x2), asin(y1), 0f);
+            }
+
+            return euler.yxz;
+        }
+
+        /// <summary>
+        /// Returns the Euler angle representation of the quaternion following the YZX rotation order.
+        /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin.
+        /// </summary>
+        /// <param name="q">The quaternion to convert to Euler angles.</param>
+        /// <returns>The Euler angle representation of the quaternion in YZX order.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3 EulerYZX(quaternion q)
+        {
+            const float epsilon = 1e-6f;
+            const float cutoff = (1f - 2f * epsilon) * (1f - 2f * epsilon);
+
+            // prepare the data
+            var qv = q.value;
+            var d1 = qv * qv.wwww * float4(2f); //xw, yw, zw, ww
+            var d2 = qv * qv.yzxw * float4(2f); //xy, yz, zx, ww
+            var d3 = qv * qv;
+            var euler = Unity.Mathematics.float3.zero;
+
+            var y1 = d2.x - d1.z;
+            if (y1 * y1 < cutoff)
+            {
+                var x1 = d2.z + d1.y;
+                var x2 = d3.x + d3.w - d3.z - d3.y;
+                var z1 = d2.y + d1.x;
+                var z2 = d3.y + d3.w - d3.x - d3.z;
+                euler = float3(atan2(x1, x2), -asin(y1), atan2(z1, z2));
+            }
+            else //yxy
+            {
+                y1 = clamp(y1, -1f, 1f);
+                var abcd = float4(d2.x, d1.z, d2.y, d1.x);
+                var x1 = 2f * (abcd.x * abcd.w + abcd.y * abcd.z); //2(ad+bc)
+                var x2 = csum(abcd * abcd * float4(-1f, 1f, -1f, 1f));
+                euler = float3(atan2(x1, x2), -asin(y1), 0f);
+            }
+
+            return euler.zxy;
+        }
+
+        /// <summary>
+        /// Returns the Euler angle representation of the quaternion following the ZXY rotation order.
+        /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin.
+        /// </summary>
+        /// <param name="q">The quaternion to convert to Euler angles.</param>
+        /// <returns>The Euler angle representation of the quaternion in ZXY order.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3 EulerZXY(quaternion q)
+        {
+            const float epsilon = 1e-6f;
+            const float cutoff = (1f - 2f * epsilon) * (1f - 2f * epsilon);
+
+            // prepare the data
+            var qv = q.value;
+            var d1 = qv * qv.wwww * float4(2f); //xw, yw, zw, ww
+            var d2 = qv * qv.yzxw * float4(2f); //xy, yz, zx, ww
+            var d3 = qv * qv;
+            var euler = Unity.Mathematics.float3.zero;
+
+            var y1 = d2.y - d1.x;
+            if (y1 * y1 < cutoff)
+            {
+                var x1 = d2.x + d1.z;
+                var x2 = d3.y + d3.w - d3.x - d3.z;
+                var z1 = d2.z + d1.y;
+                var z2 = d3.z + d3.w - d3.x - d3.y;
+                euler = float3(atan2(x1, x2), -asin(y1), atan2(z1, z2));
+            }
+            else //zxz
+            {
+                y1 = clamp(y1, -1f, 1f);
+                var abcd = float4(d2.z, d1.y, d2.y, d1.x);
+                var x1 = 2f * (abcd.x * abcd.w + abcd.y * abcd.z); //2(ad+bc)
+                var x2 = csum(abcd * abcd * float4(-1f, 1f, -1f, 1f));
+                euler = float3(atan2(x1, x2), -asin(y1), 0f);
+            }
+
+            return euler.yzx;
+        }
+
+        /// <summary>
+        /// Returns the Euler angle representation of the quaternion following the ZYX rotation order.
+        /// All rotation angles are in radians and clockwise when looking along the rotation axis towards the origin.
+        /// </summary>
+        /// <param name="q">The quaternion to convert to Euler angles.</param>
+        /// <returns>The Euler angle representation of the quaternion in ZYX order.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3 EulerZYX(quaternion q)
+        {
+            const float epsilon = 1e-6f;
+            const float cutoff = (1f - 2f * epsilon) * (1f - 2f * epsilon);
+
+            var qv = q.value;
+            var d1 = qv * qv.wwww * float4(2f); //xw, yw, zw, ww
+            var d2 = qv * qv.yzxw * float4(2f); //xy, yz, zx, ww
+            var d3 = qv * qv;
+            var euler = Unity.Mathematics.float3.zero;
+
+            var y1 = d2.z + d1.y;
+            if (y1 * y1 < cutoff)
+            {
+                var x1 = -d2.x + d1.z;
+                var x2 = d3.x + d3.w - d3.y - d3.z;
+                var z1 = -d2.y + d1.x;
+                var z2 = d3.z + d3.w - d3.y - d3.x;
+                euler = float3(atan2(x1, x2), asin(y1), atan2(z1, z2));
+            }
+            else //zxz
+            {
+                y1 = clamp(y1, -1f, 1f);
+                var abcd = float4(d2.z, d1.y, d2.y, d1.x);
+                var x1 = 2f * (abcd.x * abcd.w + abcd.y * abcd.z); //2(ad+bc)
+                var x2 = csum(abcd * abcd * float4(-1f, 1f, -1f, 1f));
+                euler = float3(atan2(x1, x2), asin(y1), 0f);
+            }
+
+            return euler.zyx;
+        }
+
+        /// <summary>
+        /// Returns the Euler angle representation of the quaternion. The returned angles depend on the specified order to apply the
+        /// three rotations around the principal axes. All rotation angles are in radians and clockwise when looking along the
+        /// rotation axis towards the origin.
+        /// When the rotation order is known at compile time, to get the best performance you should use the specific
+        /// Euler rotation constructors such as EulerZXY(...).
+        /// </summary>
+        /// <param name="q">The quaternion to convert to Euler angles.</param>
+        /// <param name="order">The order in which the rotations are applied.</param>
+        /// <returns>The Euler angle representation of the quaternion in the specified order.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3 Euler(quaternion q, math.RotationOrder order = math.RotationOrder.Default)
+        {
+            switch (order)
+            {
+                case math.RotationOrder.XYZ:
+                    return EulerXYZ(q);
+                case math.RotationOrder.XZY:
+                    return EulerXZY(q);
+                case math.RotationOrder.YXZ:
+                    return EulerYXZ(q);
+                case math.RotationOrder.YZX:
+                    return EulerYZX(q);
+                case math.RotationOrder.ZXY:
+                    return EulerZXY(q);
+                case math.RotationOrder.ZYX:
+                    return EulerZYX(q);
+                default:
+                    return Unity.Mathematics.float3.zero;
+            }
+        }
 
         // Internal
 
diff --git a/src/Unity.Mathematics/quaternion.cs b/src/Unity.Mathematics/quaternion.cs
index ae7b0601..3c09d991 100644
--- a/src/Unity.Mathematics/quaternion.cs
+++ b/src/Unity.Mathematics/quaternion.cs
@@ -666,13 +666,7 @@ public static float3 rotate(quaternion q, float3 v)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static quaternion nlerp(quaternion q1, quaternion q2, float t)
         {
-            float dt = dot(q1, q2);
-            if(dt < 0.0f)
-            {
-                q2.value = -q2.value;
-            }
-
-            return normalize(quaternion(lerp(q1.value, q2.value, t)));
+            return normalize(q1.value + t * (chgsign(q2.value, dot(q1, q2)) - q1.value));
         }
 
         /// <summary>Returns the result of a spherical interpolation between two quaternions q1 and a2 using an interpolation parameter t.</summary>
@@ -705,6 +699,17 @@ public static quaternion slerp(quaternion q1, quaternion q2, float t)
             }
         }
 
+        /// <summary>Returns the angle in radians between two unit quaternions.</summary>
+        /// <param name="q1">The first quaternion.</param>
+        /// <param name="q2">The second quaternion.</param>
+        /// <returns>The angle between two unit quaternions.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float angle(quaternion q1, quaternion q2)
+        {
+            float diff = asin(length(normalize(mul(conjugate(q1), q2)).value.xyz));
+            return diff + diff;
+        }
+
         /// <summary>Returns a uint hash code of a quaternion.</summary>
         /// <param name="q">The quaternion to hash.</param>
         /// <returns>The hash code for the input quaternion.</returns>

From 207633bee8306d2da1540ea81b6415f8f83bc0ed Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Thu, 6 Jan 2022 15:41:22 -0800
Subject: [PATCH 13/94] Copy over SVD implementation from Unity.Animation.

Tests pass in Rider, but it's likely that it's broken for Burst. Must check.
---
 src/Tests/Tests/Shared/TestSvd.cs             | 210 ++++++++++++++++++
 src/Tests/Unity.Mathematics.Tests.csproj      |   2 +
 .../Unity.Mathematics.csproj                  |   1 +
 src/Unity.Mathematics/svd.cs                  | 187 ++++++++++++++++
 4 files changed, 400 insertions(+)
 create mode 100644 src/Tests/Tests/Shared/TestSvd.cs
 create mode 100644 src/Unity.Mathematics/svd.cs

diff --git a/src/Tests/Tests/Shared/TestSvd.cs b/src/Tests/Tests/Shared/TestSvd.cs
new file mode 100644
index 00000000..d74bc26d
--- /dev/null
+++ b/src/Tests/Tests/Shared/TestSvd.cs
@@ -0,0 +1,210 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    class FloatAbsoluteEqualityComparer : IEqualityComparer<float>
+    {
+        readonly float m_AllowedError;
+
+        public FloatAbsoluteEqualityComparer(float allowedError) =>
+            m_AllowedError = allowedError;
+
+        public bool Equals(float expected, float actual) =>
+            math.abs(expected - actual) < m_AllowedError;
+
+        public int GetHashCode(float value) => 0;
+    }
+
+    class QuaternionAbsoluteEqualityComparer : IEqualityComparer<quaternion>
+    {
+        readonly float m_AllowedError;
+
+        public QuaternionAbsoluteEqualityComparer(float allowedError) =>
+            m_AllowedError = allowedError;
+
+        public bool Equals(quaternion expected, quaternion actual) =>
+            (math.lengthsq(expected) == 0f && math.lengthsq(actual) == 0f) || math.abs(math.dot(expected, actual)) > (1f - m_AllowedError);
+
+        public int GetHashCode(quaternion value) => 0;
+    }
+
+    [TestFixture]
+    public class TestSvd
+    {
+        const float k_SVDTolerance = 1e-4f;
+        static readonly FloatAbsoluteEqualityComparer k_FloatComparer = new FloatAbsoluteEqualityComparer(k_SVDTolerance);
+        static readonly QuaternionAbsoluteEqualityComparer k_QuaternionComparer = new QuaternionAbsoluteEqualityComparer(k_SVDTolerance);
+
+        // Validate Penrose condition that [aba = a]
+        static void ValidatePenrose1(in float3x3 a, in float3x3 b)
+        {
+            var testA = math.mul(math.mul(a, b), a);
+
+            Assert.That(testA.c0.x, Is.EqualTo(a.c0.x).Using(k_FloatComparer));
+            Assert.That(testA.c0.y, Is.EqualTo(a.c0.y).Using(k_FloatComparer));
+            Assert.That(testA.c0.z, Is.EqualTo(a.c0.z).Using(k_FloatComparer));
+            Assert.That(testA.c1.x, Is.EqualTo(a.c1.x).Using(k_FloatComparer));
+            Assert.That(testA.c1.y, Is.EqualTo(a.c1.y).Using(k_FloatComparer));
+            Assert.That(testA.c1.z, Is.EqualTo(a.c1.z).Using(k_FloatComparer));
+            Assert.That(testA.c2.x, Is.EqualTo(a.c2.x).Using(k_FloatComparer));
+            Assert.That(testA.c2.y, Is.EqualTo(a.c2.y).Using(k_FloatComparer));
+            Assert.That(testA.c2.z, Is.EqualTo(a.c2.z).Using(k_FloatComparer));
+        }
+
+        // Validate Penrose condition that [transpose(ab) = ab]
+        static void ValidatePenrose2(in float3x3 a, in float3x3 b)
+        {
+            var ab = math.mul(a, b);
+            var testAB = math.transpose(ab);
+
+            Assert.That(testAB.c0.x, Is.EqualTo(ab.c0.x).Using(k_FloatComparer));
+            Assert.That(testAB.c0.y, Is.EqualTo(ab.c0.y).Using(k_FloatComparer));
+            Assert.That(testAB.c0.z, Is.EqualTo(ab.c0.z).Using(k_FloatComparer));
+            Assert.That(testAB.c1.x, Is.EqualTo(ab.c1.x).Using(k_FloatComparer));
+            Assert.That(testAB.c1.y, Is.EqualTo(ab.c1.y).Using(k_FloatComparer));
+            Assert.That(testAB.c1.z, Is.EqualTo(ab.c1.z).Using(k_FloatComparer));
+            Assert.That(testAB.c2.x, Is.EqualTo(ab.c2.x).Using(k_FloatComparer));
+            Assert.That(testAB.c2.y, Is.EqualTo(ab.c2.y).Using(k_FloatComparer));
+            Assert.That(testAB.c2.z, Is.EqualTo(ab.c2.z).Using(k_FloatComparer));
+        }
+
+        static void ValidateSingular(in float3x3 a) =>
+            Assert.That(math.determinant(a), Is.EqualTo(0f).Using(k_FloatComparer));
+
+        [TestCompiler]
+        public void CanSVDInverseNonSingularFloat3x3()
+        {
+            var mat = math.float3x3(
+                math.float3(9f, 1f, 2f),
+                math.float3(3f, 8f, 4f),
+                math.float3(5f, 6f, 7f)
+            );
+
+            var inv = svd.svdInverse(mat);
+            var testIdentity = math.mul(mat, inv);
+
+            Assert.That(testIdentity.c0.x, Is.EqualTo(1f).Using(k_FloatComparer));
+            Assert.That(testIdentity.c0.y, Is.EqualTo(0f).Using(k_FloatComparer));
+            Assert.That(testIdentity.c0.z, Is.EqualTo(0f).Using(k_FloatComparer));
+            Assert.That(testIdentity.c1.x, Is.EqualTo(0f).Using(k_FloatComparer));
+            Assert.That(testIdentity.c1.y, Is.EqualTo(1f).Using(k_FloatComparer));
+            Assert.That(testIdentity.c1.z, Is.EqualTo(0f).Using(k_FloatComparer));
+            Assert.That(testIdentity.c2.x, Is.EqualTo(0f).Using(k_FloatComparer));
+            Assert.That(testIdentity.c2.y, Is.EqualTo(0f).Using(k_FloatComparer));
+            Assert.That(testIdentity.c2.z, Is.EqualTo(1f).Using(k_FloatComparer));
+        }
+
+        [TestCompiler]
+        public void CanSVDInverseFloat3x3With_NullColumn()
+        {
+            var mat = math.float3x3(
+                math.float3(9f, 1f, 0f),
+                math.float3(3f, 8f, 0f),
+                math.float3(5f, 6f, 0f)
+            );
+
+            ValidateSingular(mat);
+            var inv = svd.svdInverse(mat);
+
+            ValidatePenrose1(mat, inv);
+            ValidatePenrose1(inv, mat);
+            ValidatePenrose2(mat, inv);
+            ValidatePenrose2(inv, mat);
+        }
+
+        [TestCompiler]
+        public void CanSVDInverseFloat3x3With_NullRow()
+        {
+            var mat = math.float3x3(
+                math.float3(9f, 1f, 2f),
+                math.float3(0f, 0f, 0f),
+                math.float3(5f, 6f, 7f)
+            );
+
+            ValidateSingular(mat);
+            var inv = svd.svdInverse(mat);
+
+            ValidatePenrose1(mat, inv);
+            ValidatePenrose1(inv, mat);
+            ValidatePenrose2(mat, inv);
+            ValidatePenrose2(inv, mat);
+        }
+
+        [TestCompiler]
+        public void CanSVDInverseFloat3x3With_LinearDependentColumn()
+        {
+            var mat = math.float3x3(
+                math.float3(9f, 4f, 2f),
+                math.float3(3f, 8f, 4f),
+                math.float3(5f, 14f, 7f)
+            );
+
+            ValidateSingular(mat);
+            var inv = svd.svdInverse(mat);
+
+            ValidatePenrose1(mat, inv);
+            ValidatePenrose1(inv, mat);
+            ValidatePenrose2(mat, inv);
+            ValidatePenrose2(inv, mat);
+        }
+
+        [TestCompiler]
+        public void CanSVDInverseFloat3x3With_LinearDependentRow()
+        {
+            var mat = math.float3x3(
+                math.float3(9f, 1f, 2f),
+                math.float3(10f, 12f, 14f),
+                math.float3(5f, 6f, 7f)
+            );
+
+            ValidateSingular(mat);
+            var inv = svd.svdInverse(mat);
+
+            ValidatePenrose1(mat, inv);
+            ValidatePenrose1(inv, mat);
+            ValidatePenrose2(mat, inv);
+            ValidatePenrose2(inv, mat);
+        }
+
+        [TestCompiler]
+        public void CanSVDInverseFloat3x3With_RotatedZeroScale()
+        {
+            var m102030 = math.float3x3(quaternion.Euler(math.radians(10f), math.radians(20f), math.radians(30f)));
+            var parent  = svd.mulScale(m102030, math.float3(1f, 1f, 0f));
+            var mat     = math.mul(parent, m102030);
+
+            ValidateSingular(mat);
+            var inv = svd.svdInverse(mat);
+
+            ValidatePenrose1(mat, inv);
+            ValidatePenrose1(inv, mat);
+            ValidatePenrose2(mat, inv);
+            ValidatePenrose2(inv, mat);
+        }
+
+        // Case 928598: The errors appear, when GameObject has a child with ParticleSystem which is rotated along the y-axis to -180 and is moved
+        [TestCompiler]
+        public void CanExtractSVDRotationFromFloat3x3With_X180_Y0_Z181()
+        {
+            var q = quaternion.Euler(math.radians(180f), math.radians(0f), math.radians(181f));
+            var qSVD = svd.svdRotation(math.float3x3(q));
+
+            Assert.That(qSVD, Is.EqualTo(q).Using(k_QuaternionComparer));
+        }
+
+        // Case 938548: Assertion failed on expression: 'CompareApproximately(det, 1.0F, .005f)' when scaling system to 0 on at least 2 axes
+        [TestCompiler]
+        public void CanExtractSVDRotationFromFloat3x3With_ZeroScaleXY()
+        {
+            var q0 = quaternion.Euler(math.radians(10f), math.radians(20f), math.radians(30f));
+            var m0 = math.float3x3(q0);
+            var m0Scaled = svd.mulScale(m0, math.float3(1f, 0f, 0f));
+            var q1 = svd.svdRotation(m0Scaled);
+            var m1 = math.float3x3(q1);
+
+            Assert.That(math.length(m0.c0 - m1.c0), Is.EqualTo(0f).Using(k_FloatComparer));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Tests/Unity.Mathematics.Tests.csproj b/src/Tests/Unity.Mathematics.Tests.csproj
index 4ca36bde..d6fe8748 100644
--- a/src/Tests/Unity.Mathematics.Tests.csproj
+++ b/src/Tests/Unity.Mathematics.Tests.csproj
@@ -12,6 +12,7 @@
     <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <TargetFrameworkProfile />
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -106,6 +107,7 @@
     <Compile Include="Tests\Shared\TestPlane.cs" />
     <Compile Include="Tests\Shared\TestQuaternion.cs" />
     <Compile Include="Tests\Shared\TestRigidTransform.cs" />
+    <Compile Include="Tests\Shared\TestSvd.cs" />
     <Compile Include="Tests\TestMath2.cs" />
     <Compile Include="Tests\TestRandom.cs" />
     <Compile Include="Tests\Shared\TestUint2.gen.cs" />
diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj
index 11383fbb..da1856ac 100644
--- a/src/Unity.Mathematics/Unity.Mathematics.csproj
+++ b/src/Unity.Mathematics/Unity.Mathematics.csproj
@@ -138,6 +138,7 @@
     <Compile Include="quaternion.cs" />
     <Compile Include="rigid_transform.cs" />
     <Compile Include="random.cs" />
+    <Compile Include="svd.cs" />
     <Compile Include="uint2.gen.cs" />
     <Compile Include="uint2x2.gen.cs" />
     <Compile Include="uint2x3.gen.cs" />
diff --git a/src/Unity.Mathematics/svd.cs b/src/Unity.Mathematics/svd.cs
new file mode 100644
index 00000000..f7aae2c8
--- /dev/null
+++ b/src/Unity.Mathematics/svd.cs
@@ -0,0 +1,187 @@
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+namespace Unity.Mathematics
+{
+    // SVD algorithm as decribed in:
+    // Computing the singular value decomposition of 3x3 matrices with minimal branching and elementary floating point operations,
+    // A.McAdams, A.Selle, R.Tamstorf, J.Teran and E.Sifakis, University of Wisconsin - Madison technical report TR1690, May 2011
+    [Il2CppEagerStaticClassConstruction]
+    class svd
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void condSwap(bool c, ref float x, ref float y)
+        {
+            var tmp = x;
+            x = math.select(x, y, c);
+            y = math.select(y, tmp, c);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void condNegSwap(bool c, ref float3 x, ref float3 y)
+        {
+            var tmp = -x;
+            x = math.select(x, y, c);
+            y = math.select(y, tmp, c);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static quaternion condNegSwapQuat(bool c, quaternion q, float4 mask)
+        {
+            const float halfSqrt2 = 0.707106781186548f;
+            return math.mul(q, math.select(quaternion.identity.value, mask * halfSqrt2, c));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void sortSingularValues(ref float3x3 b, ref quaternion v)
+        {
+            var l0 = math.lengthsq(b.c0);
+            var l1 = math.lengthsq(b.c1);
+            var l2 = math.lengthsq(b.c2);
+
+            var c = l0 < l1;
+            condNegSwap(c, ref b.c0, ref b.c1);
+            v = condNegSwapQuat(c, v, math.float4(0f, 0f, 1f, 1f));
+            condSwap(c, ref l0, ref l1);
+
+            c = l0 < l2;
+            condNegSwap(c, ref b.c0, ref b.c2);
+            v = condNegSwapQuat(c, v, math.float4(0f, -1f, 0f, 1f));
+            condSwap(c, ref l0, ref l2);
+
+            c = l1 < l2;
+            condNegSwap(c, ref b.c1, ref b.c2);
+            v = condNegSwapQuat(c, v, math.float4(1f, 0f, 0f, 1f));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static quaternion approxGivensQuat(float3 pq, float4 mask)
+        {
+            const float c8 = 0.923879532511287f; // cos(pi/8)
+            const float s8 = 0.38268343236509f; // sin(pi/8)
+            const float g = 5.82842712474619f; // 3 + 2 * sqrt(2)
+
+            var ch = 2f * (pq.x - pq.y); // approx cos(a/2)
+            var sh = pq.z; // approx sin(a/2)
+            var r = math.select(math.float4(s8, s8, s8, c8), math.float4(sh, sh, sh, ch), g * sh * sh < ch * ch) * mask;
+            return math.normalize(r);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static quaternion qrGivensQuat(float2 pq, float4 mask)
+        {
+            var l = math.sqrt(pq.x * pq.x + pq.y * pq.y);
+            var sh = math.select(0f, pq.y, l > k_EpsilonNormalSqrt);
+            var ch = math.abs(pq.x) + math.max(l, k_EpsilonNormalSqrt);
+            condSwap(pq.x < 0f, ref sh, ref ch);
+
+            return math.normalize(math.float4(sh, sh, sh, ch) * mask);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static quaternion givensQRFactorization(float3x3 b, out float3x3 r)
+        {
+            var u = qrGivensQuat(math.float2(b.c0.x, b.c0.y), math.float4(0f, 0f, 1f, 1f));
+            var qmt = math.float3x3(math.conjugate(u));
+            r = math.mul(qmt, b);
+
+            var q = qrGivensQuat(math.float2(r.c0.x, r.c0.z), math.float4(0f, -1f, 0f, 1f));
+            u = math.mul(u, q);
+            qmt = math.float3x3(math.conjugate(q));
+            r = math.mul(qmt, r);
+
+            q = qrGivensQuat(math.float2(r.c1.y, r.c1.z), math.float4(1f, 0f, 0f, 1f));
+            u = math.mul(u, q);
+            qmt = math.float3x3(math.conjugate(q));
+            r = math.mul(qmt, r);
+
+            return u;
+        }
+
+        static quaternion jacobiIteration(ref float3x3 s, int iterations = 5)
+        {
+            float3x3 qm;
+            quaternion q;
+            quaternion v = quaternion.identity;
+
+            for (int i = 0; i < iterations; ++i)
+            {
+                q = approxGivensQuat(math.float3(s.c0.x, s.c1.y, s.c0.y), math.float4(0f, 0f, 1f, 1f));
+                v = math.mul(v, q);
+                qm = math.float3x3(q);
+                s = math.mul(math.mul(math.transpose(qm), s), qm);
+
+                q = approxGivensQuat(math.float3(s.c1.y, s.c2.z, s.c1.z), math.float4(1f, 0f, 0f, 1f));
+                v = math.mul(v, q);
+                qm = math.float3x3(q);
+                s = math.mul(math.mul(math.transpose(qm), s), qm);
+
+                q = approxGivensQuat(math.float3(s.c2.z, s.c0.x, s.c2.x), math.float4(0f, 1f, 0f, 1f));
+                v = math.mul(v, q);
+                qm = math.float3x3(q);
+                s = math.mul(math.mul(math.transpose(qm), s), qm);
+            }
+
+            return v;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static float3 singularValuesDecomposition(float3x3 a, out quaternion u, out quaternion v)
+        {
+            u = quaternion.identity;
+            v = quaternion.identity;
+
+            var s = math.mul(math.transpose(a), a);
+            v = jacobiIteration(ref s);
+            var b = math.float3x3(v);
+            b = math.mul(a, b);
+            sortSingularValues(ref b, ref v);
+            u = givensQRFactorization(b, out var e);
+
+            return math.float3(e.c0.x, e.c1.y, e.c2.z);
+        }
+
+        const float k_EpsilonDeterminant = 1e-6f;
+        const float k_EpsilonRCP = 1e-9f;
+        const float k_EpsilonNormalSqrt = 1e-15f;
+
+        /// <summary>
+        /// Matrix columns multiplied by scale components
+        /// m.c0.x * s.x | m.c1.x * s.y | m.c2.x * s.z
+        /// m.c0.y * s.x | m.c1.y * s.y | m.c2.y * s.z
+        /// m.c0.z * s.x | m.c1.z * s.y | m.c2.z * s.z
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3x3 mulScale(float3x3 m, float3 s) => new float3x3(m.c0 * s.x, m.c1 * s.y, m.c2 * s.z);
+
+        /// <summary>
+        /// Matrix rows multiplied by scale components
+        /// m.c0.x * s.x | m.c1.x * s.x | m.c2.x * s.x
+        /// m.c0.y * s.y | m.c1.y * s.y | m.c2.y * s.y
+        /// m.c0.z * s.z | m.c1.z * s.z | m.c2.z * s.z
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static float3x3 scaleMul(float3 s, float3x3 m) => new float3x3(m.c0 * s, m.c1 * s, m.c2 * s);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static float3 rcpsafe(float3 x, float epsilon = k_EpsilonRCP) =>
+            math.select(math.rcp(x), float3.zero, math.abs(x) < epsilon);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static internal float3x3 svdInverse(float3x3 a)
+        {
+            var e = singularValuesDecomposition(a, out var u, out var v);
+            var um = math.float3x3(u);
+            var vm = math.float3x3(v);
+
+            return math.mul(vm, scaleMul(rcpsafe(e, k_EpsilonDeterminant), math.transpose(um)));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static internal quaternion svdRotation(float3x3 a)
+        {
+            singularValuesDecomposition(a, out var u, out var v);
+            return math.mul(u, math.conjugate(v));
+        }
+    }
+}
\ No newline at end of file

From fe48b7a7847d7c88baab3c74b946f2882a15c41b Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Thu, 6 Jan 2022 18:07:39 -0800
Subject: [PATCH 14/94] Make test asserts burst compatible.

---
 src/Tests/Tests/Shared/TestSvd.cs | 107 ++++++++++++------------------
 1 file changed, 41 insertions(+), 66 deletions(-)

diff --git a/src/Tests/Tests/Shared/TestSvd.cs b/src/Tests/Tests/Shared/TestSvd.cs
index d74bc26d..a0191e31 100644
--- a/src/Tests/Tests/Shared/TestSvd.cs
+++ b/src/Tests/Tests/Shared/TestSvd.cs
@@ -4,53 +4,28 @@
 
 namespace Unity.Mathematics.Tests
 {
-    class FloatAbsoluteEqualityComparer : IEqualityComparer<float>
-    {
-        readonly float m_AllowedError;
-
-        public FloatAbsoluteEqualityComparer(float allowedError) =>
-            m_AllowedError = allowedError;
-
-        public bool Equals(float expected, float actual) =>
-            math.abs(expected - actual) < m_AllowedError;
-
-        public int GetHashCode(float value) => 0;
-    }
-
-    class QuaternionAbsoluteEqualityComparer : IEqualityComparer<quaternion>
-    {
-        readonly float m_AllowedError;
-
-        public QuaternionAbsoluteEqualityComparer(float allowedError) =>
-            m_AllowedError = allowedError;
-
-        public bool Equals(quaternion expected, quaternion actual) =>
-            (math.lengthsq(expected) == 0f && math.lengthsq(actual) == 0f) || math.abs(math.dot(expected, actual)) > (1f - m_AllowedError);
-
-        public int GetHashCode(quaternion value) => 0;
-    }
-
     [TestFixture]
     public class TestSvd
     {
         const float k_SVDTolerance = 1e-4f;
-        static readonly FloatAbsoluteEqualityComparer k_FloatComparer = new FloatAbsoluteEqualityComparer(k_SVDTolerance);
-        static readonly QuaternionAbsoluteEqualityComparer k_QuaternionComparer = new QuaternionAbsoluteEqualityComparer(k_SVDTolerance);
+
+        static bool QuaternionEquals(quaternion expected, quaternion actual, float tolerance) =>
+            (math.lengthsq(expected) == 0f && math.lengthsq(actual) == 0f) || math.abs(math.dot(expected, actual)) > (1f - tolerance);
 
         // Validate Penrose condition that [aba = a]
         static void ValidatePenrose1(in float3x3 a, in float3x3 b)
         {
             var testA = math.mul(math.mul(a, b), a);
 
-            Assert.That(testA.c0.x, Is.EqualTo(a.c0.x).Using(k_FloatComparer));
-            Assert.That(testA.c0.y, Is.EqualTo(a.c0.y).Using(k_FloatComparer));
-            Assert.That(testA.c0.z, Is.EqualTo(a.c0.z).Using(k_FloatComparer));
-            Assert.That(testA.c1.x, Is.EqualTo(a.c1.x).Using(k_FloatComparer));
-            Assert.That(testA.c1.y, Is.EqualTo(a.c1.y).Using(k_FloatComparer));
-            Assert.That(testA.c1.z, Is.EqualTo(a.c1.z).Using(k_FloatComparer));
-            Assert.That(testA.c2.x, Is.EqualTo(a.c2.x).Using(k_FloatComparer));
-            Assert.That(testA.c2.y, Is.EqualTo(a.c2.y).Using(k_FloatComparer));
-            Assert.That(testA.c2.z, Is.EqualTo(a.c2.z).Using(k_FloatComparer));
+            TestUtils.AreEqual(a.c0.x, testA.c0.x, k_SVDTolerance);
+            TestUtils.AreEqual(a.c0.y, testA.c0.y, k_SVDTolerance);
+            TestUtils.AreEqual(a.c0.z, testA.c0.z, k_SVDTolerance);
+            TestUtils.AreEqual(a.c1.x, testA.c1.x, k_SVDTolerance);
+            TestUtils.AreEqual(a.c1.y, testA.c1.y, k_SVDTolerance);
+            TestUtils.AreEqual(a.c1.z, testA.c1.z, k_SVDTolerance);
+            TestUtils.AreEqual(a.c2.x, testA.c2.x, k_SVDTolerance);
+            TestUtils.AreEqual(a.c2.y, testA.c2.y, k_SVDTolerance);
+            TestUtils.AreEqual(a.c2.z, testA.c2.z, k_SVDTolerance);
         }
 
         // Validate Penrose condition that [transpose(ab) = ab]
@@ -59,22 +34,22 @@ static void ValidatePenrose2(in float3x3 a, in float3x3 b)
             var ab = math.mul(a, b);
             var testAB = math.transpose(ab);
 
-            Assert.That(testAB.c0.x, Is.EqualTo(ab.c0.x).Using(k_FloatComparer));
-            Assert.That(testAB.c0.y, Is.EqualTo(ab.c0.y).Using(k_FloatComparer));
-            Assert.That(testAB.c0.z, Is.EqualTo(ab.c0.z).Using(k_FloatComparer));
-            Assert.That(testAB.c1.x, Is.EqualTo(ab.c1.x).Using(k_FloatComparer));
-            Assert.That(testAB.c1.y, Is.EqualTo(ab.c1.y).Using(k_FloatComparer));
-            Assert.That(testAB.c1.z, Is.EqualTo(ab.c1.z).Using(k_FloatComparer));
-            Assert.That(testAB.c2.x, Is.EqualTo(ab.c2.x).Using(k_FloatComparer));
-            Assert.That(testAB.c2.y, Is.EqualTo(ab.c2.y).Using(k_FloatComparer));
-            Assert.That(testAB.c2.z, Is.EqualTo(ab.c2.z).Using(k_FloatComparer));
+            TestUtils.AreEqual(ab.c0.x, testAB.c0.x, k_SVDTolerance);
+            TestUtils.AreEqual(ab.c0.y, testAB.c0.y, k_SVDTolerance);
+            TestUtils.AreEqual(ab.c0.z, testAB.c0.z, k_SVDTolerance);
+            TestUtils.AreEqual(ab.c1.x, testAB.c1.x, k_SVDTolerance);
+            TestUtils.AreEqual(ab.c1.y, testAB.c1.y, k_SVDTolerance);
+            TestUtils.AreEqual(ab.c1.z, testAB.c1.z, k_SVDTolerance);
+            TestUtils.AreEqual(ab.c2.x, testAB.c2.x, k_SVDTolerance);
+            TestUtils.AreEqual(ab.c2.y, testAB.c2.y, k_SVDTolerance);
+            TestUtils.AreEqual(ab.c2.z, testAB.c2.z, k_SVDTolerance);
         }
 
         static void ValidateSingular(in float3x3 a) =>
-            Assert.That(math.determinant(a), Is.EqualTo(0f).Using(k_FloatComparer));
+            TestUtils.AreEqual(0.0f, math.determinant(a), k_SVDTolerance);
 
         [TestCompiler]
-        public void CanSVDInverseNonSingularFloat3x3()
+        public static void CanSVDInverseNonSingularFloat3x3()
         {
             var mat = math.float3x3(
                 math.float3(9f, 1f, 2f),
@@ -85,19 +60,19 @@ public void CanSVDInverseNonSingularFloat3x3()
             var inv = svd.svdInverse(mat);
             var testIdentity = math.mul(mat, inv);
 
-            Assert.That(testIdentity.c0.x, Is.EqualTo(1f).Using(k_FloatComparer));
-            Assert.That(testIdentity.c0.y, Is.EqualTo(0f).Using(k_FloatComparer));
-            Assert.That(testIdentity.c0.z, Is.EqualTo(0f).Using(k_FloatComparer));
-            Assert.That(testIdentity.c1.x, Is.EqualTo(0f).Using(k_FloatComparer));
-            Assert.That(testIdentity.c1.y, Is.EqualTo(1f).Using(k_FloatComparer));
-            Assert.That(testIdentity.c1.z, Is.EqualTo(0f).Using(k_FloatComparer));
-            Assert.That(testIdentity.c2.x, Is.EqualTo(0f).Using(k_FloatComparer));
-            Assert.That(testIdentity.c2.y, Is.EqualTo(0f).Using(k_FloatComparer));
-            Assert.That(testIdentity.c2.z, Is.EqualTo(1f).Using(k_FloatComparer));
+            TestUtils.AreEqual(1f, testIdentity.c0.x, k_SVDTolerance);
+            TestUtils.AreEqual(0f, testIdentity.c0.y, k_SVDTolerance);
+            TestUtils.AreEqual(0f, testIdentity.c0.z, k_SVDTolerance);
+            TestUtils.AreEqual(0f, testIdentity.c1.x, k_SVDTolerance);
+            TestUtils.AreEqual(1f, testIdentity.c1.y, k_SVDTolerance);
+            TestUtils.AreEqual(0f, testIdentity.c1.z, k_SVDTolerance);
+            TestUtils.AreEqual(0f, testIdentity.c2.x, k_SVDTolerance);
+            TestUtils.AreEqual(0f, testIdentity.c2.y, k_SVDTolerance);
+            TestUtils.AreEqual(1f, testIdentity.c2.z, k_SVDTolerance);
         }
 
         [TestCompiler]
-        public void CanSVDInverseFloat3x3With_NullColumn()
+        public static void CanSVDInverseFloat3x3With_NullColumn()
         {
             var mat = math.float3x3(
                 math.float3(9f, 1f, 0f),
@@ -115,7 +90,7 @@ public void CanSVDInverseFloat3x3With_NullColumn()
         }
 
         [TestCompiler]
-        public void CanSVDInverseFloat3x3With_NullRow()
+        public static void CanSVDInverseFloat3x3With_NullRow()
         {
             var mat = math.float3x3(
                 math.float3(9f, 1f, 2f),
@@ -133,7 +108,7 @@ public void CanSVDInverseFloat3x3With_NullRow()
         }
 
         [TestCompiler]
-        public void CanSVDInverseFloat3x3With_LinearDependentColumn()
+        public static void CanSVDInverseFloat3x3With_LinearDependentColumn()
         {
             var mat = math.float3x3(
                 math.float3(9f, 4f, 2f),
@@ -151,7 +126,7 @@ public void CanSVDInverseFloat3x3With_LinearDependentColumn()
         }
 
         [TestCompiler]
-        public void CanSVDInverseFloat3x3With_LinearDependentRow()
+        public static void CanSVDInverseFloat3x3With_LinearDependentRow()
         {
             var mat = math.float3x3(
                 math.float3(9f, 1f, 2f),
@@ -169,7 +144,7 @@ public void CanSVDInverseFloat3x3With_LinearDependentRow()
         }
 
         [TestCompiler]
-        public void CanSVDInverseFloat3x3With_RotatedZeroScale()
+        public static void CanSVDInverseFloat3x3With_RotatedZeroScale()
         {
             var m102030 = math.float3x3(quaternion.Euler(math.radians(10f), math.radians(20f), math.radians(30f)));
             var parent  = svd.mulScale(m102030, math.float3(1f, 1f, 0f));
@@ -186,17 +161,17 @@ public void CanSVDInverseFloat3x3With_RotatedZeroScale()
 
         // Case 928598: The errors appear, when GameObject has a child with ParticleSystem which is rotated along the y-axis to -180 and is moved
         [TestCompiler]
-        public void CanExtractSVDRotationFromFloat3x3With_X180_Y0_Z181()
+        public static void CanExtractSVDRotationFromFloat3x3With_X180_Y0_Z181()
         {
             var q = quaternion.Euler(math.radians(180f), math.radians(0f), math.radians(181f));
             var qSVD = svd.svdRotation(math.float3x3(q));
 
-            Assert.That(qSVD, Is.EqualTo(q).Using(k_QuaternionComparer));
+            TestUtils.IsTrue(QuaternionEquals(q, qSVD, k_SVDTolerance));
         }
 
         // Case 938548: Assertion failed on expression: 'CompareApproximately(det, 1.0F, .005f)' when scaling system to 0 on at least 2 axes
         [TestCompiler]
-        public void CanExtractSVDRotationFromFloat3x3With_ZeroScaleXY()
+        public static void CanExtractSVDRotationFromFloat3x3With_ZeroScaleXY()
         {
             var q0 = quaternion.Euler(math.radians(10f), math.radians(20f), math.radians(30f));
             var m0 = math.float3x3(q0);
@@ -204,7 +179,7 @@ public void CanExtractSVDRotationFromFloat3x3With_ZeroScaleXY()
             var q1 = svd.svdRotation(m0Scaled);
             var m1 = math.float3x3(q1);
 
-            Assert.That(math.length(m0.c0 - m1.c0), Is.EqualTo(0f).Using(k_FloatComparer));
+            TestUtils.AreEqual(0.0f, math.length(m0.c0 - m1.c0), k_SVDTolerance);
         }
     }
 }
\ No newline at end of file

From a9fb50f8d970ebd526d8785f44c2e1f22d475cda Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Fri, 7 Jan 2022 15:34:13 -0800
Subject: [PATCH 15/94] Copy over pseudoinverse from Unity.Animation.

---
 src/Unity.Mathematics/quaternion.cs | 62 ++++++++++++++++++++++++++++-
 src/Unity.Mathematics/svd.cs        |  9 +++--
 2 files changed, 66 insertions(+), 5 deletions(-)

diff --git a/src/Unity.Mathematics/quaternion.cs b/src/Unity.Mathematics/quaternion.cs
index 3c09d991..f6549d8a 100644
--- a/src/Unity.Mathematics/quaternion.cs
+++ b/src/Unity.Mathematics/quaternion.cs
@@ -710,6 +710,67 @@ public static float angle(quaternion q1, quaternion q2)
             return diff + diff;
         }
 
+        /// <summary>
+        /// Extracts the rotation from a matrix that potentially has scale.
+        /// </summary>
+        /// <param name="a">Matrix to extract rotation from</param>
+        /// <returns>Extracted rotation</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static quaternion rotation(float3x3 m)
+        {
+            float det = math.determinant(m);
+            if (math.abs(1f - det) < svd.k_EpsilonDeterminant)
+                return math.quaternion(m);
+
+            if (math.abs(det) > svd.k_EpsilonDeterminant)
+            {
+                float3x3 tmp = svd.mulScale(m, math.rsqrt(math.float3(math.lengthsq(m.c0), math.lengthsq(m.c1), math.lengthsq(m.c2))));
+                if (math.abs(1f - math.determinant(tmp)) < svd.k_EpsilonDeterminant)
+                    return math.quaternion(tmp);
+            }
+
+            return svd.svdRotation(m);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static float3x3 adj(float3x3 m, out float det)
+        {
+            float3x3 adjT;
+            adjT.c0 = math.cross(m.c1, m.c2);
+            adjT.c1 = math.cross(m.c2, m.c0);
+            adjT.c2 = math.cross(m.c0, m.c1);
+            det = math.dot(m.c0, adjT.c0);
+
+            return math.transpose(adjT);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static bool adjInverse(float3x3 m, out float3x3 i, float epsilon = svd.k_EpsilonNormal)
+        {
+            i = adj(m, out float det);
+            bool c = math.abs(det) > epsilon;
+            float3 detInv = math.select(math.float3(1f), math.rcp(det), c);
+            i = svd.scaleMul(detInv, i);
+            return c;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3x3 pseudoinverse(float3x3 m)
+        {
+            float scaleSq = 0.333333f * (math.lengthsq(m.c0) + math.lengthsq(m.c1) + math.lengthsq(m.c2));
+            if (scaleSq < svd.k_EpsilonNormal)
+                return Mathematics.float3x3.zero;
+
+            float3 scaleInv = math.rsqrt(scaleSq);
+            float3x3 ms = svd.mulScale(m, scaleInv);
+            if (!adjInverse(ms, out float3x3 i, svd.k_EpsilonDeterminant))
+            {
+                i = svd.svdInverse(ms);
+            }
+
+            return svd.mulScale(i, scaleInv);
+        }
+
         /// <summary>Returns a uint hash code of a quaternion.</summary>
         /// <param name="q">The quaternion to hash.</param>
         /// <returns>The hash code for the input quaternion.</returns>
@@ -732,7 +793,6 @@ public static uint4 hashwide(quaternion q)
             return hashwide(q.value);
         }
 
-
         /// <summary>
         /// Transforms the forward vector by a quaternion.
         /// </summary>
diff --git a/src/Unity.Mathematics/svd.cs b/src/Unity.Mathematics/svd.cs
index f7aae2c8..f3adeec4 100644
--- a/src/Unity.Mathematics/svd.cs
+++ b/src/Unity.Mathematics/svd.cs
@@ -141,9 +141,10 @@ static float3 singularValuesDecomposition(float3x3 a, out quaternion u, out quat
             return math.float3(e.c0.x, e.c1.y, e.c2.z);
         }
 
-        const float k_EpsilonDeterminant = 1e-6f;
-        const float k_EpsilonRCP = 1e-9f;
-        const float k_EpsilonNormalSqrt = 1e-15f;
+        public const float k_EpsilonDeterminant = 1e-6f;
+        public const float k_EpsilonRCP = 1e-9f;
+        public const float k_EpsilonNormalSqrt = 1e-15f;
+        public const float k_EpsilonNormal = 1e-30f;
 
         /// <summary>
         /// Matrix columns multiplied by scale components
@@ -161,7 +162,7 @@ static float3 singularValuesDecomposition(float3x3 a, out quaternion u, out quat
         /// m.c0.z * s.z | m.c1.z * s.z | m.c2.z * s.z
         /// </summary>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static float3x3 scaleMul(float3 s, float3x3 m) => new float3x3(m.c0 * s, m.c1 * s, m.c2 * s);
+        public static float3x3 scaleMul(float3 s, float3x3 m) => new float3x3(m.c0 * s, m.c1 * s, m.c2 * s);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static float3 rcpsafe(float3 x, float epsilon = k_EpsilonRCP) =>

From c8dea008610a1e9b0affb7db1737f2e3c8d593bc Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Fri, 7 Jan 2022 16:37:35 -0800
Subject: [PATCH 16/94] Move pseudoinverse to matrix.cs math class.

---
 src/Unity.Mathematics/matrix.cs     | 17 +++++++++++++++++
 src/Unity.Mathematics/quaternion.cs | 17 -----------------
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/Unity.Mathematics/matrix.cs b/src/Unity.Mathematics/matrix.cs
index fe4a679c..251aef65 100644
--- a/src/Unity.Mathematics/matrix.cs
+++ b/src/Unity.Mathematics/matrix.cs
@@ -1089,5 +1089,22 @@ public static float3x3 orthonormalize(float3x3 i)
 
             return o;
         }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3x3 pseudoinverse(float3x3 m)
+        {
+            float scaleSq = 0.333333f * (math.lengthsq(m.c0) + math.lengthsq(m.c1) + math.lengthsq(m.c2));
+            if (scaleSq < svd.k_EpsilonNormal)
+                return Mathematics.float3x3.zero;
+
+            float3 scaleInv = math.rsqrt(scaleSq);
+            float3x3 ms = svd.mulScale(m, scaleInv);
+            if (!adjInverse(ms, out float3x3 i, svd.k_EpsilonDeterminant))
+            {
+                i = svd.svdInverse(ms);
+            }
+
+            return svd.mulScale(i, scaleInv);
+        }
     }
 }
diff --git a/src/Unity.Mathematics/quaternion.cs b/src/Unity.Mathematics/quaternion.cs
index f6549d8a..dba3996b 100644
--- a/src/Unity.Mathematics/quaternion.cs
+++ b/src/Unity.Mathematics/quaternion.cs
@@ -754,23 +754,6 @@ static bool adjInverse(float3x3 m, out float3x3 i, float epsilon = svd.k_Epsilon
             return c;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3x3 pseudoinverse(float3x3 m)
-        {
-            float scaleSq = 0.333333f * (math.lengthsq(m.c0) + math.lengthsq(m.c1) + math.lengthsq(m.c2));
-            if (scaleSq < svd.k_EpsilonNormal)
-                return Mathematics.float3x3.zero;
-
-            float3 scaleInv = math.rsqrt(scaleSq);
-            float3x3 ms = svd.mulScale(m, scaleInv);
-            if (!adjInverse(ms, out float3x3 i, svd.k_EpsilonDeterminant))
-            {
-                i = svd.svdInverse(ms);
-            }
-
-            return svd.mulScale(i, scaleInv);
-        }
-
         /// <summary>Returns a uint hash code of a quaternion.</summary>
         /// <param name="q">The quaternion to hash.</param>
         /// <returns>The hash code for the input quaternion.</returns>

From 1865dbabb4bf79d6d89e6d8b5af10310e4368b1c Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Fri, 7 Jan 2022 17:23:01 -0800
Subject: [PATCH 17/94] Added two small tests for pseudoinverse.

---
 src/Tests/Tests/Shared/TestMatrix.cs | 41 ++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/src/Tests/Tests/Shared/TestMatrix.cs b/src/Tests/Tests/Shared/TestMatrix.cs
index 5bc45842..558ce482 100644
--- a/src/Tests/Tests/Shared/TestMatrix.cs
+++ b/src/Tests/Tests/Shared/TestMatrix.cs
@@ -1169,5 +1169,46 @@ public static void float3x3_from_float4x4_without_new()
 
             TestUtils.AreEqual(expected, float3x3(f4x4));
         }
+
+        [TestCompiler]
+        public static void float3x3_pseudoinverse_non_singular()
+        {
+            const float kTolerance = 1e-5f;
+
+            // A random 3x3 matrix, non-singular, generated from octave.
+            var a = new float3x3(
+                0.806710600852966308594f, 0.985506594181060791016f, 0.593669593334197998047f,
+                0.0869068726897239685059f, 0.754145503044128417969f, 0.222692146897315979004f,
+                0.917483031749725341797f, 0.443894535303115844727f, 0.138771042227745056152f);
+
+            // The regular inverse of a, as computed by octave.
+            var expected = new float3x3(
+                -0.0299495235085487365723f, -0.654392063617706298828f, 1.17825806140899658203f,
+                -0.992458224296569824219f, 2.23384380340576171875f, 0.661037027835845947266f,
+                3.37264156341552734375f, -2.81901407241821289063f, -2.69841933250427246094f);
+
+            TestUtils.AreEqual(expected, pseudoinverse(a), kTolerance);
+            TestUtils.AreEqual(expected, inverse(a), kTolerance);
+        }
+
+        [TestCompiler]
+        public static void float3x3_pseudoinverse_singular()
+        {
+            const float kTolerance = 1e-5f;
+
+            // A singular matrix.
+            var a = new float3x3(
+                0.0548239313066005706787f, 0.462397903203964233398f, 0.0501357726752758026123f,
+                0.0548239313066005706787f, 0.462397903203964233398f, 0.0501357726752758026123f,
+                0.938165545463562011719f, 0.542225778102874755859f, 0.10684439539909362793f);
+
+            // The pseudoinverse computed by octave.
+            var expected = new float3x3(
+                -0.675357639789581298828f, -0.675357699394226074219f, 1.14166188240051269531f,
+                1.15268361568450927734f, 1.15268361568450927734f, -0.140613287687301635742f,
+                0.0803283303976058959961f, 0.0803283303976058959961f, 0.0484490357339382171631f);
+
+            TestUtils.AreEqual(expected, pseudoinverse(a), kTolerance);
+        }
     }
 }

From 43288c5e59a53b418934d59d2f2c5248ea305c4b Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Wed, 12 Jan 2022 16:47:38 -0800
Subject: [PATCH 18/94] rotation() tests.

---
 src/Tests/Tests/Shared/TestQuaternion.cs | 80 ++++++++++++++++++++++++
 1 file changed, 80 insertions(+)

diff --git a/src/Tests/Tests/Shared/TestQuaternion.cs b/src/Tests/Tests/Shared/TestQuaternion.cs
index 5f531b0e..301725ee 100644
--- a/src/Tests/Tests/Shared/TestQuaternion.cs
+++ b/src/Tests/Tests/Shared/TestQuaternion.cs
@@ -380,5 +380,85 @@ public static void quaternion_angle()
             angle = math.angle(q, nq);
             TestUtils.AreEqual(0f, angle);
         }
+
+        [TestCompiler]
+        public static void quaternion_rotation_from_3x3_identity()
+        {
+            const float tolerance = 1e-5f;
+            var q = rotation(float3x3.identity);
+            TestUtils.AreEqual(quaternion.identity, q, tolerance);
+        }
+
+        [TestCompiler]
+        public static void quaternion_rotation_from_3x3_with_uniform_scale()
+        {
+            const float tolerance = 1e-5f;
+            var random = new Random(6173u);
+            var expectedQuaternion = random.NextQuaternionRotation();
+            var m = new float3x3(expectedQuaternion);
+            m = mul(m, float3x3.Scale(5.18f));
+            var actualQuaternion = rotation(m);
+            TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
+        }
+
+        [TestCompiler]
+        public static void quaternion_rotation_from_3x3_with_nonuniform_scale()
+        {
+            const float tolerance = 1e-5f;
+            var m = new float3x3(
+                2.0f, 0.0f, 0.0f,
+                0.0f, 1.5f, 0.0f,
+                0.0f, 0.0f, 3.1f);
+            var q = rotation(m);
+            TestUtils.AreEqual(quaternion.identity, q, tolerance);
+        }
+
+        [TestCompiler]
+        public static void quaternion_rotation_from_3x3_with_negative_scale_x()
+        {
+            const float tolerance = 1e-5f;
+            var random = new Random(281u);
+            var expectedQuaternion = random.NextQuaternionRotation();
+            var m = new float3x3(expectedQuaternion);
+            m = mul(m, float3x3.Scale(-1.5f, 0.2f, 51.281f));
+            var actualQuaternion = rotation(m);
+            TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
+        }
+
+        [TestCompiler]
+        public static void quaternion_rotation_from_3x3_with_negative_scale_y()
+        {
+            const float tolerance = 1e-5f;
+            var random = new Random(10000u);
+            var expectedQuaternion = random.NextQuaternionRotation();
+            var m = new float3x3(expectedQuaternion);
+            m = mul(m, float3x3.Scale(1.5f, -0.2f, 51.281f));
+            var actualQuaternion = rotation(m);
+            TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
+        }
+
+        [TestCompiler]
+        public static void quaternion_rotation_from_3x3_with_negative_scale_z()
+        {
+            const float tolerance = 1e-5f;
+            var random = new Random(9891712u);
+            var expectedQuaternion = random.NextQuaternionRotation();
+            var m = new float3x3(expectedQuaternion);
+            m = mul(m, float3x3.Scale(1.5f, 0.2f, -51.281f));
+            var actualQuaternion = rotation(m);
+            TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
+        }
+
+        [TestCompiler]
+        public static void quaternion_rotation_from_3x3_with_negative_nonuniform_scale()
+        {
+            const float tolerance = 1e-5f;
+            var random = new Random(912u);
+            var expectedQuaternion = random.NextQuaternionRotation();
+            var m = new float3x3(expectedQuaternion);
+            m = mul(m, float3x3.Scale(-1.5f, -0.2f, -51.281f));
+            var actualQuaternion = rotation(m);
+            TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
+        }
     }
 }

From 793f0e0aeafaf00e090b2fd63e2ef260047a823f Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Wed, 12 Jan 2022 17:04:27 -0800
Subject: [PATCH 19/94] Update doc parameter.

---
 src/Unity.Mathematics/quaternion.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Unity.Mathematics/quaternion.cs b/src/Unity.Mathematics/quaternion.cs
index dba3996b..15007f7d 100644
--- a/src/Unity.Mathematics/quaternion.cs
+++ b/src/Unity.Mathematics/quaternion.cs
@@ -713,7 +713,7 @@ public static float angle(quaternion q1, quaternion q2)
         /// <summary>
         /// Extracts the rotation from a matrix that potentially has scale.
         /// </summary>
-        /// <param name="a">Matrix to extract rotation from</param>
+        /// <param name="m">Matrix to extract rotation from</param>
         /// <returns>Extracted rotation</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static quaternion rotation(float3x3 m)

From 28d218a2c6aa629277ccfcca1075b6eb5362fdcc Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Wed, 12 Jan 2022 17:28:11 -0800
Subject: [PATCH 20/94] Documentation for pseudoinverse().

---
 src/Unity.Mathematics/matrix.cs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/Unity.Mathematics/matrix.cs b/src/Unity.Mathematics/matrix.cs
index 251aef65..6589eb1b 100644
--- a/src/Unity.Mathematics/matrix.cs
+++ b/src/Unity.Mathematics/matrix.cs
@@ -1090,6 +1090,11 @@ public static float3x3 orthonormalize(float3x3 i)
             return o;
         }
 
+        /// <summary>
+        /// Computes the pseudoinverse of a matrix.
+        /// </summary>
+        /// <param name="m">Matrix to invert.</param>
+        /// <returns>The pseudoinverse of m.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float3x3 pseudoinverse(float3x3 m)
         {

From 66d79ec047e17a59fba8f7269919f58454f13019 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Wed, 12 Jan 2022 17:47:26 -0800
Subject: [PATCH 21/94] Adding meta files.

---
 src/Tests/Tests/Shared/TestSvd.cs.meta | 11 +++++++++++
 src/Unity.Mathematics/svd.cs.meta      | 11 +++++++++++
 2 files changed, 22 insertions(+)
 create mode 100644 src/Tests/Tests/Shared/TestSvd.cs.meta
 create mode 100644 src/Unity.Mathematics/svd.cs.meta

diff --git a/src/Tests/Tests/Shared/TestSvd.cs.meta b/src/Tests/Tests/Shared/TestSvd.cs.meta
new file mode 100644
index 00000000..824a25f5
--- /dev/null
+++ b/src/Tests/Tests/Shared/TestSvd.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8218cb7d87dac4432871cd5bd00fd333
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/src/Unity.Mathematics/svd.cs.meta b/src/Unity.Mathematics/svd.cs.meta
new file mode 100644
index 00000000..e7924355
--- /dev/null
+++ b/src/Unity.Mathematics/svd.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bc4f01dc4f3d8489f85ca8dff8563871
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

From 93077524b55d23906061af2ea992b7a1fdb77436 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Wed, 12 Jan 2022 17:48:38 -0800
Subject: [PATCH 22/94] Spelling fix.

---
 src/Unity.Mathematics/svd.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Unity.Mathematics/svd.cs b/src/Unity.Mathematics/svd.cs
index f3adeec4..87985b31 100644
--- a/src/Unity.Mathematics/svd.cs
+++ b/src/Unity.Mathematics/svd.cs
@@ -3,7 +3,7 @@
 
 namespace Unity.Mathematics
 {
-    // SVD algorithm as decribed in:
+    // SVD algorithm as described in:
     // Computing the singular value decomposition of 3x3 matrices with minimal branching and elementary floating point operations,
     // A.McAdams, A.Selle, R.Tamstorf, J.Teran and E.Sifakis, University of Wisconsin - Madison technical report TR1690, May 2011
     [Il2CppEagerStaticClassConstruction]

From 894eb10f12bc4a9b8ca615ed178d02ded55a45c8 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Wed, 12 Jan 2022 17:54:47 -0800
Subject: [PATCH 23/94] Sort modifiers.

---
 src/Unity.Mathematics/svd.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Unity.Mathematics/svd.cs b/src/Unity.Mathematics/svd.cs
index 87985b31..2ff93d38 100644
--- a/src/Unity.Mathematics/svd.cs
+++ b/src/Unity.Mathematics/svd.cs
@@ -169,7 +169,7 @@ static float3 rcpsafe(float3 x, float epsilon = k_EpsilonRCP) =>
             math.select(math.rcp(x), float3.zero, math.abs(x) < epsilon);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static internal float3x3 svdInverse(float3x3 a)
+        internal static float3x3 svdInverse(float3x3 a)
         {
             var e = singularValuesDecomposition(a, out var u, out var v);
             var um = math.float3x3(u);
@@ -179,7 +179,7 @@ static internal float3x3 svdInverse(float3x3 a)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static internal quaternion svdRotation(float3x3 a)
+        internal static quaternion svdRotation(float3x3 a)
         {
             singularValuesDecomposition(a, out var u, out var v);
             return math.mul(u, math.conjugate(v));

From 2f043eedba14a5891a1254ee36ec0dd065674ec6 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Thu, 13 Jan 2022 11:00:15 -0800
Subject: [PATCH 24/94] License file update. (#209)

---
 LICENSE.md     | 2 +-
 src/LICENSE.md | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/LICENSE.md b/LICENSE.md
index 3ab46903..a95cdfbe 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,4 +1,4 @@
-com.unity.mathematics copyright © 2019 Unity Technologies
+com.unity.mathematics copyright © 2022 Unity Technologies ApS
 
 Licensed under the Unity Companion License for Unity-dependent projects (see https://unity3d.com/legal/licenses/unity_companion_license).
 Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.
\ No newline at end of file
diff --git a/src/LICENSE.md b/src/LICENSE.md
index 3ab46903..a95cdfbe 100755
--- a/src/LICENSE.md
+++ b/src/LICENSE.md
@@ -1,4 +1,4 @@
-com.unity.mathematics copyright © 2019 Unity Technologies
+com.unity.mathematics copyright © 2022 Unity Technologies ApS
 
 Licensed under the Unity Companion License for Unity-dependent projects (see https://unity3d.com/legal/licenses/unity_companion_license).
 Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.
\ No newline at end of file

From 5d9b83546659fc4aa603c296808d9f79df92d116 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Thu, 13 Jan 2022 17:07:06 -0800
Subject: [PATCH 25/94] Add pseudoinverse performance test.

---
 .../VectorGenerator.cs                        |  3 +
 .../TestInverse.gen.cs                        | 84 +++++++++++++++++++
 2 files changed, 87 insertions(+)

diff --git a/src/Unity.Mathematics.CodeGen/VectorGenerator.cs b/src/Unity.Mathematics.CodeGen/VectorGenerator.cs
index 87f7fbb0..a6c203b3 100644
--- a/src/Unity.Mathematics.CodeGen/VectorGenerator.cs
+++ b/src/Unity.Mathematics.CodeGen/VectorGenerator.cs
@@ -3224,6 +3224,9 @@ void GenerateInversePerformanceTests(StringBuilder str)
             GeneratePerformanceTest(str, "quaternion_inverse", new PerformanceTestArrayArgument[] {
                 new PerformanceTestArrayArgument { m_ElementType = "quaternion", m_MemberName = "q", m_ElementInitializer = "quaternion.identity" },
             }, "args.q[i] = math.inverse(args.q[i]);", 10000);
+            GeneratePerformanceTest(str, "pseudoinverse", new PerformanceTestArrayArgument[] {
+                new PerformanceTestArrayArgument { m_ElementType = "float3x3", m_MemberName = "m", m_ElementInitializer = "new float3x3(0.054824f, 0.462398f, 0.050136f, 0.054824f, 0.462398f, 0.050136f, 0.938166f, 0.542226f, 0.106844f)" },
+            }, "args.m[i] = math.pseudoinverse(args.m[i]);", 1000);
 
             EndPerformanceTestCodeGen(str);
         }
diff --git a/src/Unity.Mathematics.PerformanceTests/TestInverse.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestInverse.gen.cs
index 1359b2a3..26bfc7da 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestInverse.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestInverse.gen.cs
@@ -596,6 +596,90 @@ public void quaternion_inverse_burst()
             var args = new quaternion_inverse.Arguments();
             args.Init();
 
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class pseudoinverse
+        {
+            public const int iterations = 1000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public float3x3* m;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    m = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        m[i] = new float3x3(0.054824f, 0.462398f, 0.050136f, 0.054824f, 0.462398f, 0.050136f, 0.938166f, 0.542226f, 0.106844f);
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(m, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.m[i] = math.pseudoinverse(args.m[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void pseudoinverse_mono()
+        {
+            pseudoinverse.TestFunction testFunction = pseudoinverse.MonoTestFunction;
+            var args = new pseudoinverse.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void pseudoinverse_burst()
+        {
+            FunctionPointer<pseudoinverse.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<pseudoinverse.TestFunction>(pseudoinverse.BurstTestFunction);
+            var args = new pseudoinverse.Arguments();
+            args.Init();
+
             var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
             {
                 testFunction.Invoke(ref args);

From 6f60f46ac6ef0e15893ea1d420e1b787a4126d48 Mon Sep 17 00:00:00 2001
From: Olivier Dionne <olivierd@unity3d.com>
Date: Fri, 14 Jan 2022 09:02:32 -0500
Subject: [PATCH 26/94] Bring affine transform from Unity.Animation

---
 src/Unity.Mathematics/affine_transform.cs     | 188 ++++++++++++++++++
 .../affine_transform.cs.meta                  |  11 +
 2 files changed, 199 insertions(+)
 create mode 100644 src/Unity.Mathematics/affine_transform.cs
 create mode 100644 src/Unity.Mathematics/affine_transform.cs.meta

diff --git a/src/Unity.Mathematics/affine_transform.cs b/src/Unity.Mathematics/affine_transform.cs
new file mode 100644
index 00000000..b1611141
--- /dev/null
+++ b/src/Unity.Mathematics/affine_transform.cs
@@ -0,0 +1,188 @@
+using System;
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+using static Unity.Mathematics.math;
+
+namespace Unity.Mathematics
+{
+    /// <summary>
+    /// An affine transformation type.
+    /// </summary>
+    [Il2CppEagerStaticClassConstruction]
+    [Serializable]
+    public struct AffineTransform : IEquatable<AffineTransform>, IFormattable
+    {
+        /// <summary>
+        /// The rotation and scale part of the affine transformation.
+        /// </summary>
+        public float3x3 rs;
+
+        /// <summary>
+        /// The translation part of the affine transformation.
+        /// </summary>
+        public float3 t;
+
+        /// <summary>An AffineTransform representing the identity transform.</summary>
+        public static readonly AffineTransform identity = new AffineTransform(float3.zero, float3x3.identity);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public AffineTransform(float3 t, float3x3 rs)
+        {
+            this.rs = rs;
+            this.t = t;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public AffineTransform(float3 t, quaternion r)
+        {
+            this.rs = math.float3x3(r);
+            this.t = t;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public AffineTransform(float3 t, quaternion r, float3 s)
+        {
+            this.rs = svd.mulScale(math.float3x3(r), s);
+            this.t = t;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public AffineTransform(RigidTransform rigid)
+        {
+            rs = math.float3x3(rigid.rot);
+            t = rigid.pos;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public AffineTransform(float3x3 m)
+        {
+            rs = m;
+            t = float3.zero;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public AffineTransform(float3x4 m)
+        {
+            rs = math.float3x3(m.c0, m.c1, m.c2);
+            t = m.c3;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public AffineTransform(float4x4 m)
+        {
+            rs = math.float3x3(m.c0.xyz, m.c1.xyz, m.c2.xyz);
+            t = m.c3.xyz;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float3x4(AffineTransform m) { return new float3x4(m.rs.c0, m.rs.c1, m.rs.c2, m.t); }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float4x4(AffineTransform m) { return new float4x4(new float4(m.rs.c0, 0f), new float4(m.rs.c1, 0f), new float4(m.rs.c2, 0f), new float4(m.t, 1f)); }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(AffineTransform x) { return rs.Equals(x.rs) && t.Equals(x.t); }
+
+        public override bool Equals(object o) { return o is AffineTransform converted && Equals(converted); }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode() { return (int)math.hash(this); }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override string ToString()
+        {
+            return string.Format("AffineTransform(({0}f, {1}f, {2}f,  {3}f, {4}f, {5}f,  {6}f, {7}f, {8}f), ({9}f, {10}f, {11}f))",
+                rs.c0.x, rs.c1.x, rs.c2.x, rs.c0.y, rs.c1.y, rs.c2.y, rs.c0.z, rs.c1.z, rs.c2.z, t.x, t.y, t.z
+            );
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            return string.Format("AffineTransform(({0}f, {1}f, {2}f,  {3}f, {4}f, {5}f,  {6}f, {7}f, {8}f), ({9}f, {10}f, {11}f))",
+                rs.c0.x.ToString(format, formatProvider), rs.c1.x.ToString(format, formatProvider), rs.c2.x.ToString(format, formatProvider),
+                rs.c0.y.ToString(format, formatProvider), rs.c1.y.ToString(format, formatProvider), rs.c2.y.ToString(format, formatProvider),
+                rs.c0.z.ToString(format, formatProvider), rs.c1.z.ToString(format, formatProvider), rs.c2.z.ToString(format, formatProvider),
+                t.x.ToString(format, formatProvider), t.y.ToString(format, formatProvider), t.z.ToString(format, formatProvider)
+            );
+        }
+    }
+
+    public static partial class math
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform AffineTransform(float3 translation, quaternion rotation) { return AffineTransform(translation, rotation); }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform AffineTransform(float3 translation, float3x3 rs) { return new AffineTransform(translation, rs); }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform AffineTransform(float4x4 m) { return new AffineTransform(m); }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform AffineTransform(float3x4 m) { return new AffineTransform(m); }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform AffineTransform(float3 translation, quaternion rotation, float3 scale) { return new AffineTransform(translation, rotation, scale); }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float4x4 float4x4(AffineTransform transform) { return new float4x4(new float4(transform.rs.c0, 0f), new float4(transform.rs.c1, 0f), new float4(transform.rs.c2, 0f), new float4(transform.t, 1f)); }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3x4 float3x4(AffineTransform transform) { return new float3x4(transform.rs.c0, transform.rs.c1, transform.rs.c2, transform.t); }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3 mul(AffineTransform a, float3 v)
+        {
+            return a.t + mul(a.rs, v);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform mul(AffineTransform a, AffineTransform b)
+        {
+            return new AffineTransform(mul(a, b.t), mul(a.rs, b.rs));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform mul(float3x3 rs, AffineTransform b)
+        {
+            return new AffineTransform(mul(rs, b.t), mul(rs, b.rs));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform mul(AffineTransform a, float3x3 rs)
+        {
+            return new AffineTransform(a.t, mul(rs, a.rs));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform inverse(AffineTransform a)
+        {
+            AffineTransform inv;
+            inv.rs = pseudoinverse(a.rs);
+            inv.t = mul(inv.rs, -a.t);
+            return inv;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void decompose(AffineTransform a, out float3 translation, out quaternion rotation, out float3 scale)
+        {
+            translation = a.t;
+            rotation = math.rotation(a.rs);
+            var sm = mul(float3x3(conjugate(rotation)), a.rs);
+            scale = float3(sm.c0.x, sm.c1.y, sm.c2.z);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint hash(AffineTransform a)
+        {
+            return hash(a.rs) + 0xC5C5394Bu * hash(a.t);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint4 hashwide(AffineTransform a)
+        {
+            return hashwide(a.rs).xyzz + 0xC5C5394Bu * hashwide(a.t).xyzz;
+        }
+    }
+}
diff --git a/src/Unity.Mathematics/affine_transform.cs.meta b/src/Unity.Mathematics/affine_transform.cs.meta
new file mode 100644
index 00000000..19d69b1d
--- /dev/null
+++ b/src/Unity.Mathematics/affine_transform.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 25c2cff1b9e35e648980b04c895d7332
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

From 0f2a599fdef73617362841b07f4a4fe9be54515e Mon Sep 17 00:00:00 2001
From: Olivier Dionne <olivierd@unity3d.com>
Date: Fri, 14 Jan 2022 12:02:39 -0500
Subject: [PATCH 27/94] clean up

---
 src/Unity.Mathematics/affine_transform.cs | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/Unity.Mathematics/affine_transform.cs b/src/Unity.Mathematics/affine_transform.cs
index b1611141..cf5e9753 100644
--- a/src/Unity.Mathematics/affine_transform.cs
+++ b/src/Unity.Mathematics/affine_transform.cs
@@ -35,7 +35,7 @@ public AffineTransform(float3 t, float3x3 rs)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public AffineTransform(float3 t, quaternion r)
         {
-            this.rs = math.float3x3(r);
+            this.rs = float3x3(r);
             this.t = t;
         }
 
@@ -75,10 +75,10 @@ public AffineTransform(float4x4 m)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static implicit operator float3x4(AffineTransform m) { return new float3x4(m.rs.c0, m.rs.c1, m.rs.c2, m.t); }
+        public static implicit operator float3x4(AffineTransform m) { return float3x4(m.rs.c0, m.rs.c1, m.rs.c2, m.t); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static implicit operator float4x4(AffineTransform m) { return new float4x4(new float4(m.rs.c0, 0f), new float4(m.rs.c1, 0f), new float4(m.rs.c2, 0f), new float4(m.t, 1f)); }
+        public static implicit operator float4x4(AffineTransform m) { return float4x4(float4(m.rs.c0, 0f), float4(m.rs.c1, 0f), float4(m.rs.c2, 0f), float4(m.t, 1f)); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool Equals(AffineTransform x) { return rs.Equals(x.rs) && t.Equals(x.t); }
@@ -86,7 +86,7 @@ public AffineTransform(float4x4 m)
         public override bool Equals(object o) { return o is AffineTransform converted && Equals(converted); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public override int GetHashCode() { return (int)math.hash(this); }
+        public override int GetHashCode() { return (int)hash(this); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public override string ToString()
@@ -114,22 +114,22 @@ public static partial class math
         public static AffineTransform AffineTransform(float3 translation, quaternion rotation) { return AffineTransform(translation, rotation); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3 translation, float3x3 rs) { return new AffineTransform(translation, rs); }
+        public static AffineTransform AffineTransform(float3 translation, float3x3 rs) { return AffineTransform(translation, rs); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float4x4 m) { return new AffineTransform(m); }
+        public static AffineTransform AffineTransform(float4x4 m) { return AffineTransform(m); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3x4 m) { return new AffineTransform(m); }
+        public static AffineTransform AffineTransform(float3x4 m) { return AffineTransform(m); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3 translation, quaternion rotation, float3 scale) { return new AffineTransform(translation, rotation, scale); }
+        public static AffineTransform AffineTransform(float3 translation, quaternion rotation, float3 scale) { return AffineTransform(translation, rotation, scale); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4x4 float4x4(AffineTransform transform) { return new float4x4(new float4(transform.rs.c0, 0f), new float4(transform.rs.c1, 0f), new float4(transform.rs.c2, 0f), new float4(transform.t, 1f)); }
+        public static float4x4 float4x4(AffineTransform transform) { return float4x4(float4(transform.rs.c0, 0f), float4(transform.rs.c1, 0f), float4(transform.rs.c2, 0f), float4(transform.t, 1f)); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3x4 float3x4(AffineTransform transform) { return new float3x4(transform.rs.c0, transform.rs.c1, transform.rs.c2, transform.t); }
+        public static float3x4 float3x4(AffineTransform transform) { return float3x4(transform.rs.c0, transform.rs.c1, transform.rs.c2, transform.t); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float3 mul(AffineTransform a, float3 v)

From f20390ffecd1723454daf199c97214c17eda141c Mon Sep 17 00:00:00 2001
From: Olivier Dionne <olivierd@unity3d.com>
Date: Fri, 14 Jan 2022 12:39:45 -0500
Subject: [PATCH 28/94] Add missing conversion methods

---
 src/Unity.Mathematics/affine_transform.cs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/Unity.Mathematics/affine_transform.cs b/src/Unity.Mathematics/affine_transform.cs
index cf5e9753..25d9d3d3 100644
--- a/src/Unity.Mathematics/affine_transform.cs
+++ b/src/Unity.Mathematics/affine_transform.cs
@@ -113,6 +113,9 @@ public static partial class math
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static AffineTransform AffineTransform(float3 translation, quaternion rotation) { return AffineTransform(translation, rotation); }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform AffineTransform(float3 translation, quaternion rotation, float3 scale) { return AffineTransform(translation, rotation, scale); }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static AffineTransform AffineTransform(float3 translation, float3x3 rs) { return AffineTransform(translation, rs); }
 
@@ -123,7 +126,10 @@ public static partial class math
         public static AffineTransform AffineTransform(float3x4 m) { return AffineTransform(m); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3 translation, quaternion rotation, float3 scale) { return AffineTransform(translation, rotation, scale); }
+        public static AffineTransform AffineTransform(float3x3 m) { return AffineTransform(m); }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform AffineTransform(RigidTransform m) { return AffineTransform(m); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float4x4 float4x4(AffineTransform transform) { return float4x4(float4(transform.rs.c0, 0f), float4(transform.rs.c1, 0f), float4(transform.rs.c2, 0f), float4(transform.t, 1f)); }

From c5f269ce26bbb8dcb3c130f2f62abfa758e2424d Mon Sep 17 00:00:00 2001
From: Olivier Dionne <olivierd@unity3d.com>
Date: Fri, 14 Jan 2022 13:01:44 -0500
Subject: [PATCH 29/94] adding tests

---
 src/Tests/Tests/Shared/TestAffineTransform.cs | 72 +++++++++++++++++++
 .../Tests/Shared/TestAffineTransform.cs.meta  | 11 +++
 src/Unity.Mathematics/affine_transform.cs     | 14 ++--
 3 files changed, 90 insertions(+), 7 deletions(-)
 create mode 100644 src/Tests/Tests/Shared/TestAffineTransform.cs
 create mode 100644 src/Tests/Tests/Shared/TestAffineTransform.cs.meta

diff --git a/src/Tests/Tests/Shared/TestAffineTransform.cs b/src/Tests/Tests/Shared/TestAffineTransform.cs
new file mode 100644
index 00000000..f3977e43
--- /dev/null
+++ b/src/Tests/Tests/Shared/TestAffineTransform.cs
@@ -0,0 +1,72 @@
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    class TestAffineTransform
+    {
+        [TestCompiler]
+        public static void affine_transform_inverse()
+        {
+            const float tolerance = 1e-6f;
+
+            var tx = AffineTransform(float3(5, 6, 7), normalize(math.float4(1, 2, 3, 4)), float3(2, 3, 4));
+            var invTx = inverse(tx);
+
+            TestUtils.AreEqual(float4x4.identity, float4x4(mul(tx, invTx)), tolerance);
+        }
+
+        [TestCompiler]
+        public static void affine_transform_inverse_zero_rs_returns_zero()
+        {
+            const float tolerance = 1e-30f;
+
+            var tx = AffineTransform(float3(5, 6, 7), normalize(float4(1, 2, 3, 4)), float3.zero);
+            var invTx = inverse(tx);
+
+            TestUtils.AreEqual(float4x4.zero, invTx, tolerance);
+        }
+
+        [TestCompiler]
+        public static void affine_transform_inverse_pico_scale()
+        {
+            // slightly larger tolerance (vs 1e-6f) for PS4
+            const float tolerance = 2e-6f;
+
+            var tx = AffineTransform(float3(5, 6, 7), normalize(float4(1, 2, 3, 4)), float3(1e-12f, 1e-12f, 1e-12f));
+            var invTx = inverse(tx);
+
+            TestUtils.AreEqual(float4x4.identity, float4x4(mul(tx, invTx)), tolerance);
+        }
+
+        [TestCompiler]
+        public static void affine_transform_inverse_singular()
+        {
+            // it needs a bit larger tolerance for singular
+            // since it uses the svd iterative solver
+            const float tolerance = 1e-1f;
+
+            var tx = AffineTransform(float3(5, 6, 7), normalize(float4(1, 2, 3, 4)), float3(0, 3, 4));
+            var invTx = inverse(tx);
+
+            // pseudo inverse penrose #1 test
+            var testTx = mul(mul(tx, invTx), tx);
+            TestUtils.AreEqual(float4x4(tx), float4x4(testTx), tolerance);
+        }
+
+        [TestCompiler]
+        public static void affine_transform_decompose()
+        {
+            const float tolerance = 1e-6f;
+
+            var tx = AffineTransform(float3(5, 6, 7), normalize(float4(1, 2, 3, 4)), float3(2, 3, 4));
+            decompose(tx, out var t, out var r, out var s);
+
+            // Recompose matrix
+            var testTx = AffineTransform(t, r, s);
+            TestUtils.AreEqual(float4x4(tx), float4x4(testTx), tolerance);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Tests/Tests/Shared/TestAffineTransform.cs.meta b/src/Tests/Tests/Shared/TestAffineTransform.cs.meta
new file mode 100644
index 00000000..01d27e82
--- /dev/null
+++ b/src/Tests/Tests/Shared/TestAffineTransform.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 534e18de5e70ccf468bf46c917dfdac4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/src/Unity.Mathematics/affine_transform.cs b/src/Unity.Mathematics/affine_transform.cs
index 25d9d3d3..b4d740f8 100644
--- a/src/Unity.Mathematics/affine_transform.cs
+++ b/src/Unity.Mathematics/affine_transform.cs
@@ -111,25 +111,25 @@ public string ToString(string format, IFormatProvider formatProvider)
     public static partial class math
     {
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3 translation, quaternion rotation) { return AffineTransform(translation, rotation); }
+        public static AffineTransform AffineTransform(float3 translation, quaternion rotation) { return new AffineTransform(translation, rotation); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3 translation, quaternion rotation, float3 scale) { return AffineTransform(translation, rotation, scale); }
+        public static AffineTransform AffineTransform(float3 translation, quaternion rotation, float3 scale) { return new AffineTransform(translation, rotation, scale); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3 translation, float3x3 rs) { return AffineTransform(translation, rs); }
+        public static AffineTransform AffineTransform(float3 translation, float3x3 rs) { return new AffineTransform(translation, rs); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float4x4 m) { return AffineTransform(m); }
+        public static AffineTransform AffineTransform(float4x4 m) { return new AffineTransform(m); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3x4 m) { return AffineTransform(m); }
+        public static AffineTransform AffineTransform(float3x4 m) { return new AffineTransform(m); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3x3 m) { return AffineTransform(m); }
+        public static AffineTransform AffineTransform(float3x3 m) { return new AffineTransform(m); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(RigidTransform m) { return AffineTransform(m); }
+        public static AffineTransform AffineTransform(RigidTransform m) { return new AffineTransform (m); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float4x4 float4x4(AffineTransform transform) { return float4x4(float4(transform.rs.c0, 0f), float4(transform.rs.c1, 0f), float4(transform.rs.c2, 0f), float4(transform.t, 1f)); }

From 886723f820aa28163aa0f962edee00fa33885428 Mon Sep 17 00:00:00 2001
From: Olivier Dionne <olivierd@unity3d.com>
Date: Fri, 14 Jan 2022 14:30:49 -0500
Subject: [PATCH 30/94] fix test

---
 src/Tests/Tests/Shared/TestAffineTransform.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Tests/Tests/Shared/TestAffineTransform.cs b/src/Tests/Tests/Shared/TestAffineTransform.cs
index f3977e43..0a2c9f5b 100644
--- a/src/Tests/Tests/Shared/TestAffineTransform.cs
+++ b/src/Tests/Tests/Shared/TestAffineTransform.cs
@@ -15,7 +15,7 @@ public static void affine_transform_inverse()
             var tx = AffineTransform(float3(5, 6, 7), normalize(math.float4(1, 2, 3, 4)), float3(2, 3, 4));
             var invTx = inverse(tx);
 
-            TestUtils.AreEqual(float4x4.identity, float4x4(mul(tx, invTx)), tolerance);
+            TestUtils.AreEqual(float4x4.identity, mul(tx, invTx), tolerance);
         }
 
         [TestCompiler]
@@ -26,7 +26,7 @@ public static void affine_transform_inverse_zero_rs_returns_zero()
             var tx = AffineTransform(float3(5, 6, 7), normalize(float4(1, 2, 3, 4)), float3.zero);
             var invTx = inverse(tx);
 
-            TestUtils.AreEqual(float4x4.zero, invTx, tolerance);
+            TestUtils.AreEqual(float3x4.zero, invTx, tolerance);
         }
 
         [TestCompiler]
@@ -38,7 +38,7 @@ public static void affine_transform_inverse_pico_scale()
             var tx = AffineTransform(float3(5, 6, 7), normalize(float4(1, 2, 3, 4)), float3(1e-12f, 1e-12f, 1e-12f));
             var invTx = inverse(tx);
 
-            TestUtils.AreEqual(float4x4.identity, float4x4(mul(tx, invTx)), tolerance);
+            TestUtils.AreEqual(float4x4.identity, mul(tx, invTx), tolerance);
         }
 
         [TestCompiler]

From f86abb545cba4aace75afb1fce5f5fe06fa52ac1 Mon Sep 17 00:00:00 2001
From: Olivier Dionne <olivierd@unity3d.com>
Date: Fri, 14 Jan 2022 15:36:38 -0500
Subject: [PATCH 31/94] add docs

---
 src/Unity.Mathematics/affine_transform.cs | 179 ++++++++++++++++++----
 1 file changed, 150 insertions(+), 29 deletions(-)

diff --git a/src/Unity.Mathematics/affine_transform.cs b/src/Unity.Mathematics/affine_transform.cs
index b4d740f8..5b07fa7a 100644
--- a/src/Unity.Mathematics/affine_transform.cs
+++ b/src/Unity.Mathematics/affine_transform.cs
@@ -25,41 +25,57 @@ public struct AffineTransform : IEquatable<AffineTransform>, IFormattable
         /// <summary>An AffineTransform representing the identity transform.</summary>
         public static readonly AffineTransform identity = new AffineTransform(float3.zero, float3x3.identity);
 
+        /// <summary>Constructs an AffineTransform from a translation represented by a float3 vector and rotation represented by a unit quaternion.</summary>
+        /// <param name="translation">The translation vector.</param>
+        /// <param name="rotation">The rotation quaternion.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public AffineTransform(float3 t, float3x3 rs)
+        public AffineTransform(float3 translation, quaternion rotation)
         {
-            this.rs = rs;
-            this.t = t;
+            rs = float3x3(rotation);
+            t = translation;
         }
 
+        /// <summary>Constructs an AffineTransform from a translation represented by a float3 vector, rotation represented by a unit quaternion and scale represented by a float3 vector.</summary>
+        /// <param name="translation">The translation vector.</param>
+        /// <param name="rotation">The rotation quaternion.</param>
+        /// <param name="scale">The scale vector.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public AffineTransform(float3 t, quaternion r)
+        public AffineTransform(float3 translation, quaternion rotation, float3 scale)
         {
-            this.rs = float3x3(r);
-            this.t = t;
+            rs = svd.mulScale(math.float3x3(rotation), scale);
+            t = translation;
         }
 
+        /// <summary>Constructs an AffineTransform from a translation represented by float3 vector and a float3x3 matrix representing both rotation and scale.</summary>
+        /// <param name="translation">The translation vector.</param>
+        /// <param name="rotationScale">The rotation and scale matrix.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public AffineTransform(float3 t, quaternion r, float3 s)
+        public AffineTransform(float3 translation, float3x3 rotationScale)
         {
-            this.rs = svd.mulScale(math.float3x3(r), s);
-            this.t = t;
+            rs = rotationScale;
+            t = translation;
         }
 
+        /// <summary>Constructs an AffineTransform from float3x3 matrix representating both rotation and scale.</summary>
+        /// <param name="rotationScale">The rotation and scale matrix.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public AffineTransform(RigidTransform rigid)
+        public AffineTransform(float3x3 rotationScale)
         {
-            rs = math.float3x3(rigid.rot);
-            t = rigid.pos;
+            rs = rotationScale;
+            t = float3.zero;
         }
 
+        /// <summary>Constructs an AffineTransform from a RigidTransform.</summary>
+        /// <param name="rigid">The RigidTransform.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public AffineTransform(float3x3 m)
+        public AffineTransform(RigidTransform rigid)
         {
-            rs = m;
-            t = float3.zero;
+            rs = math.float3x3(rigid.rot);
+            t = rigid.pos;
         }
 
+        /// <summary>Constructs an AffineTransform from a float3x4 matrix.</summary>
+        /// <param name="m">The float3x4 matrix.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public AffineTransform(float3x4 m)
         {
@@ -67,6 +83,8 @@ public AffineTransform(float3x4 m)
             t = m.c3;
         }
 
+        /// <summary>Constructs an AffineTransform from a float4x4 matrix.</summary>
+        /// <param name="m">The float4x4 matrix.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public AffineTransform(float4x4 m)
         {
@@ -74,20 +92,34 @@ public AffineTransform(float4x4 m)
             t = m.c3.xyz;
         }
 
+        /// <summary>Implicit float3x4 cast operator.</summary>
+        /// <param name="m">The AffineTransform.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator float3x4(AffineTransform m) { return float3x4(m.rs.c0, m.rs.c1, m.rs.c2, m.t); }
 
+        /// <summary>Implicit float4x4 cast operator.</summary>
+        /// <param name="m">The AffineTransform.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator float4x4(AffineTransform m) { return float4x4(float4(m.rs.c0, 0f), float4(m.rs.c1, 0f), float4(m.rs.c2, 0f), float4(m.t, 1f)); }
 
+        /// <summary>Returns true if the AffineTransform is equal to a given AffineTransform, false otherwise.</summary>
+        /// <param name="rhs">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool Equals(AffineTransform x) { return rs.Equals(x.rs) && t.Equals(x.t); }
+        public bool Equals(AffineTransform rhs) { return rs.Equals(rhs.rs) && t.Equals(rhs.t); }
 
+        /// <summary>Returns true if the AffineTransform is equal to a given AffineTransform, false otherwise.</summary>
+        /// <param name="o">Right hand side argument to compare equality with.</param>
+        /// <returns>The result of the equality comparison.</returns>
         public override bool Equals(object o) { return o is AffineTransform converted && Equals(converted); }
 
+        /// <summary>Returns a hash code for the AffineTransform.</summary>
+        /// <returns>The computed hash code.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public override int GetHashCode() { return (int)hash(this); }
 
+        /// <summary>Returns a string representation of the AffineTransform.</summary>
+        /// <returns>String representation of the value.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public override string ToString()
         {
@@ -96,6 +128,10 @@ public override string ToString()
             );
         }
 
+        /// <summary>Returns a string representation of the AffineTransform using a specified format and culture-specific format information.</summary>
+        /// <param name="format">Format string to use during string formatting.</param>
+        /// <param name="formatProvider">Format provider to use during string formatting.</param>
+        /// <returns>String representation of the value.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public string ToString(string format, IFormatProvider formatProvider)
         {
@@ -110,57 +146,127 @@ public string ToString(string format, IFormatProvider formatProvider)
 
     public static partial class math
     {
+        /// <summary>Returns an AffineTransform constructed from a translation represented by a float3 vector and rotation represented by a unit quaternion.</summary>
+        /// <param name="translation">The AffineTransform translation.</param>
+        /// <param name="rotation">The AffineTransform rotation.</param>
+        /// <returns>The AffineTransform given the translation vector and rotation quaternion.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static AffineTransform AffineTransform(float3 translation, quaternion rotation) { return new AffineTransform(translation, rotation); }
 
+        /// <summary>Returns an AffineTransform constructed from a translation represented by a float3 vector, rotation represented by a unit quaternion and scale represented by a float3 vector.</summary>
+        /// <param name="translation">The translation vector.</param>
+        /// <param name="rotation">The rotation quaternion.</param>
+        /// <param name="scale">The scale vector.</param>
+        /// <returns>The AffineTransform given the translation vector, rotation quaternion and scale vector.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static AffineTransform AffineTransform(float3 translation, quaternion rotation, float3 scale) { return new AffineTransform(translation, rotation, scale); }
 
+        /// <summary>Returns an AffineTransform constructed from a translation represented by float3 vector and a float3x3 matrix representing both rotation and scale.</summary>
+        /// <param name="translation">The translation vector.</param>
+        /// <param name="rotationScale">The rotation and scale matrix.</param>
+        /// <returns>The AffineTransform given the translation vector and float3x3 matrix.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3 translation, float3x3 rs) { return new AffineTransform(translation, rs); }
+        public static AffineTransform AffineTransform(float3 translation, float3x3 rotationScale) { return new AffineTransform(translation, rotationScale); }
 
+        /// <summary>Returns an AffineTransform constructed from a float3x3 matrix representing both rotation and scale.</summary>
+        /// <param name="rotationScale">The rotation and scale matrix.</param>
+        /// <returns>The AffineTransform given a float3x3 matrix.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float4x4 m) { return new AffineTransform(m); }
+        public static AffineTransform AffineTransform(float3x3 rotationScale) { return new AffineTransform(rotationScale); }
 
+        /// <summary>Returns an AffineTransform constructed from a float4x4 matrix.</summary>
+        /// <param name="m">The float4x4 matrix.</param>
+        /// <returns>The AffineTransform given a float4x4 matrix.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3x4 m) { return new AffineTransform(m); }
+        public static AffineTransform AffineTransform(float4x4 m) { return new AffineTransform(m); }
 
+        /// <summary>Returns an AffineTransform constructed from a float3x4 matrix.</summary>
+        /// <param name="m">The float3x4 matrix.</param>
+        /// <returns>The AffineTransform given a float3x4 matrix.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3x3 m) { return new AffineTransform(m); }
+        public static AffineTransform AffineTransform(float3x4 m) { return new AffineTransform(m); }
 
+        /// <summary>Returns an AffineTransform constructed from a RigidTransform.</summary>
+        /// <param name="rigid">The RigidTransform.</param>
+        /// <returns>The AffineTransform given a RigidTransform.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(RigidTransform m) { return new AffineTransform (m); }
+        public static AffineTransform AffineTransform(RigidTransform rigid) { return new AffineTransform (rigid); }
 
+        /// <summary>Returns a float4x4 matrix constructed from an AffineTransform.</summary>
+        /// <param name="transform">The AffineTransform.</param>
+        /// <returns>The float4x4 matrix given an AffineTransform.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float4x4 float4x4(AffineTransform transform) { return float4x4(float4(transform.rs.c0, 0f), float4(transform.rs.c1, 0f), float4(transform.rs.c2, 0f), float4(transform.t, 1f)); }
 
+        /// <summary>Returns a float3x4 matrix constructed from an AffineTransform.</summary>
+        /// <param name="transform">The AffineTransform.</param>
+        /// <returns>The float3x4 matrix given an AffineTransform.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float3x4 float3x4(AffineTransform transform) { return float3x4(transform.rs.c0, transform.rs.c1, transform.rs.c2, transform.t); }
 
+        /// <summary>Returns the result of transforming the AffineTransform b by the AffineTransform a.</summary>
+        /// <param name="a">The AffineTransform on the left.</param>
+        /// <param name="b">The AffineTransform on the right.</param>
+        /// <returns>The AffineTransform of a transforming b.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 mul(AffineTransform a, float3 v)
+        public static AffineTransform mul(AffineTransform a, AffineTransform b)
         {
-            return a.t + mul(a.rs, v);
+            return new AffineTransform(transform(a, b.t), mul(a.rs, b.rs));
         }
 
+        /// <summary>Returns the result of transforming the AffineTransform b by a float3x3 matrix a.</summary>
+        /// <param name="a">The float3x3 matrix on the left.</param>
+        /// <param name="b">The AffineTransform on the right.</param>
+        /// <returns>The AffineTransform of a transforming b.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform mul(AffineTransform a, AffineTransform b)
+        public static AffineTransform mul(float3x3 a, AffineTransform b)
+        {
+            return new AffineTransform(mul(a, b.t), mul(a, b.rs));
+        }
+
+        /// <summary>Returns the result of transforming the float3x3 b by an AffineTransform a.</summary>
+        /// <param name="a">The AffineTransform on the left.</param>
+        /// <param name="b">The float3x3 matrix on the right.</param>
+        /// <returns>The AffineTransform of a transforming b.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static AffineTransform mul(AffineTransform a, float3x3 b)
         {
-            return new AffineTransform(mul(a, b.t), mul(a.rs, b.rs));
+            return new AffineTransform(a.t, mul(b, a.rs));
         }
 
+        /// <summary>Returns the result of transforming a float4 homogeneous coordinate by an AffineTransform.</summary>
+        /// <param name="a">The AffineTransform.</param>
+        /// <param name="pos">The position to be transformed.</param>
+        /// <returns>The transformed position.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform mul(float3x3 rs, AffineTransform b)
+        public static float4 mul(AffineTransform a, float4 pos)
         {
-            return new AffineTransform(mul(rs, b.t), mul(rs, b.rs));
+            return float4(mul(a.rs, pos.xyz) + a.t * pos.w, pos.w);
         }
 
+        /// <summary>Returns the result of rotating a float3 vector by an AffineTransform.</summary>
+        /// <param name="a">The AffineTransform.</param>
+        /// <param name="dir">The direction vector to rotate.</param>
+        /// <returns>The rotated direction vector.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform mul(AffineTransform a, float3x3 rs)
+        public static float3 rotate(AffineTransform a, float3 dir)
         {
-            return new AffineTransform(a.t, mul(rs, a.rs));
+            return mul(a.rs, dir);
         }
 
+        /// <summary>Returns the result of transforming a float3 point by an AffineTransform.</summary>
+        /// <param name="a">The AffineTransform.</param>
+        /// <param name="pos">The position to transform.</param>
+        /// <returns>The transformed position.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3 transform(AffineTransform a, float3 pos)
+        {
+            return a.t + mul(a.rs, pos);
+        }
+
+        /// <summary>Returns the inverse of an AffineTransform.</summary>
+        /// <param name="t">The AffineTransform to invert.</param>
+        /// <returns>The inverse AffineTransform.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static AffineTransform inverse(AffineTransform a)
         {
@@ -170,6 +276,11 @@ public static AffineTransform inverse(AffineTransform a)
             return inv;
         }
 
+        /// <summary>Decomposes the AffineTransform in translation, rotation and scale.</summary>
+        /// <param name="a">The AffineTransform</param>
+        /// <param name="translation">The decomposed translation vector of the AffineTransform.</param>
+        /// <param name="rotation">The decomposed rotation quaternion of the AffineTransform.</param>
+        /// <param name="scale">The decomposed scale of the AffineTransform.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static void decompose(AffineTransform a, out float3 translation, out quaternion rotation, out float3 scale)
         {
@@ -179,12 +290,22 @@ public static void decompose(AffineTransform a, out float3 translation, out quat
             scale = float3(sm.c0.x, sm.c1.y, sm.c2.z);
         }
 
+        /// <summary>Returns a uint hash code of an AffineTransform.</summary>
+        /// <param name="a">The AffineTransform to hash.</param>
+        /// <returns>The hash code of the input AffineTransform.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static uint hash(AffineTransform a)
         {
             return hash(a.rs) + 0xC5C5394Bu * hash(a.t);
         }
 
+        /// <summary>
+        /// Returns a uint4 vector hash code of an AffineTransform.
+        /// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
+        /// that are only reduced to a narrow uint hash at the very end instead of at every step.
+        /// </summary>
+        /// <param name="a">The AffineTransform to hash.</param>
+        /// <returns>The uint4 wide hash code.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static uint4 hashwide(AffineTransform a)
         {

From 6c5d6934a234981bc590fa4a7b7cb2ecad83cd1c Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Wed, 19 Jan 2022 15:34:01 -0800
Subject: [PATCH 32/94] Add test to check rotation method with tiny scale.

---
 src/Tests/Tests/Shared/TestQuaternion.cs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/Tests/Tests/Shared/TestQuaternion.cs b/src/Tests/Tests/Shared/TestQuaternion.cs
index 301725ee..0aecebce 100644
--- a/src/Tests/Tests/Shared/TestQuaternion.cs
+++ b/src/Tests/Tests/Shared/TestQuaternion.cs
@@ -460,5 +460,17 @@ public static void quaternion_rotation_from_3x3_with_negative_nonuniform_scale()
             var actualQuaternion = rotation(m);
             TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
         }
+
+        [TestCompiler]
+        public static void quaternion_rotation_from_3x3_with_tiny_scale()
+        {
+            const float tolerance = 1e-5f;
+            var random = new Random(561887u);
+            var expectedQuaternion = random.NextQuaternionRotation();
+            var m = new float3x3(expectedQuaternion);
+            m = mul(m, float3x3.Scale(1e-12f, 1e-12f, 1e-12f));
+            var actualQuaternion = rotation(m);
+            TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
+        }
     }
 }

From 2ce73c7291a6b6bf9b49c049db222eace04ea5f6 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Wed, 19 Jan 2022 15:56:40 -0800
Subject: [PATCH 33/94] Add tests for mulScale and scaleMul.

Also updated changelog.
---
 src/CHANGELOG.md                  |  3 +++
 src/Tests/Tests/Shared/TestSvd.cs | 44 +++++++++++++++++++++++++++++++
 2 files changed, 47 insertions(+)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index 9ca6b8dd..2427dc67 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -8,6 +8,9 @@
 * Added `math.chgsign` for float, float2, float3, and float4.
 * Added `math.Euler` to convert a quaternion to Euler angles.
 * Added `math.angle` to compute the angle between two unit quaternions.
+* Added `math.rotation` to extract a quaternion rotation from a float3x3 (that may have scale).
+* Added `svd.mulScale` to scale columns of a float3x3 with scaling coefficients in a float3.
+* Added `svd.scaleMul` to scale rows of a float3x3 with scaling coefficients in a float3.
 ### Changed
 * `asfloat(uint)`, `asuint(float)`, `asint(float)` and other related methods are now faster in mono without Burst. Other methods which use these will see a performance improvement.
 * Modified `quaternion.nlerp` to be branchless.
diff --git a/src/Tests/Tests/Shared/TestSvd.cs b/src/Tests/Tests/Shared/TestSvd.cs
index a0191e31..d66c4968 100644
--- a/src/Tests/Tests/Shared/TestSvd.cs
+++ b/src/Tests/Tests/Shared/TestSvd.cs
@@ -181,5 +181,49 @@ public static void CanExtractSVDRotationFromFloat3x3With_ZeroScaleXY()
 
             TestUtils.AreEqual(0.0f, math.length(m0.c0 - m1.c0), k_SVDTolerance);
         }
+
+        [TestCompiler]
+        public static void mulScale()
+        {
+            var tolerance = 1e-5f;
+
+            // Random matrix.
+            var m = new float3x3(
+                0.891724169254302978516f, 0.156217902898788452148f, 0.492261469364166259766f,
+                0.562758803367614746094f, 0.00122839550022035837173f, 0.437942296266555786133f,
+                0.2576503753662109375f, 0.200372591614723205566f, 0.515525519847869873047f);
+
+            // Random scale.
+            var scale = new float3(0.235540181398391723633f, 0.215966641902923583984f, 0.533130943775177001953f);
+            var actual = svd.mulScale(m, scale);
+            var expected = new float3x3(
+                0.210036873817443847656f, 0.0337378568947315216064f, 0.262439817190170288086f,
+                0.132552310824394226074f, 0.000265292444964870810509f, 0.233480587601661682129f,
+                0.0606870166957378387451f, 0.043273795396089553833f, 0.274842619895935058594f);
+
+            TestUtils.AreEqual(expected, actual, 1e-5);
+        }
+
+        [TestCompiler]
+        public static void scaleMul()
+        {
+            var tolerance = 1e-5f;
+
+            // Random matrix, same as in mulScale test.
+            var m = new float3x3(
+                0.891724169254302978516f, 0.156217902898788452148f, 0.492261469364166259766f,
+                0.562758803367614746094f, 0.00122839550022035837173f, 0.437942296266555786133f,
+                0.2576503753662109375f, 0.200372591614723205566f, 0.515525519847869873047f);
+
+            // Random scale, same as in mulScale test.
+            var scale = new float3(0.235540181398391723633f, 0.215966641902923583984f, 0.533130943775177001953f);
+            var actual = svd.scaleMul(scale, m);
+            var expected = new float3x3(
+                0.210036873817443847656f, 0.0367955937981605529785f, 0.115947358310222625732f,
+                0.121537126600742340088f, 0.000265292444964870810509f, 0.0945809260010719299316f,
+                0.137361392378807067871f, 0.106824830174446105957f, 0.274842619895935058594f);
+
+            TestUtils.AreEqual(expected, actual, tolerance);
+        }
     }
 }
\ No newline at end of file

From aa34b549cd156877f2693941f434729cf6b97d4b Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Wed, 19 Jan 2022 16:15:24 -0800
Subject: [PATCH 34/94] Moved scaleMul and mulScale to math class.

Also made svd class static.
---
 src/Tests/Tests/Shared/TestMath.cs  | 44 ++++++++++++++++++++++++++
 src/Tests/Tests/Shared/TestSvd.cs   | 48 ++---------------------------
 src/Unity.Mathematics/math.cs       | 24 +++++++++++++++
 src/Unity.Mathematics/matrix.cs     |  4 +--
 src/Unity.Mathematics/quaternion.cs |  4 +--
 src/Unity.Mathematics/svd.cs        | 22 ++-----------
 6 files changed, 76 insertions(+), 70 deletions(-)

diff --git a/src/Tests/Tests/Shared/TestMath.cs b/src/Tests/Tests/Shared/TestMath.cs
index ee655b8a..6f5c03f9 100644
--- a/src/Tests/Tests/Shared/TestMath.cs
+++ b/src/Tests/Tests/Shared/TestMath.cs
@@ -4077,6 +4077,50 @@ static quaternion TestRefEulerToQuat(float3 angle, math.RotationOrder order)
                 default:
                     return quaternion(float4(1f));
             }
+        }
+
+                [TestCompiler]
+        public static void mulScale()
+        {
+            var tolerance = 1e-5f;
+
+            // Random matrix.
+            var m = new float3x3(
+                0.891724169254302978516f, 0.156217902898788452148f, 0.492261469364166259766f,
+                0.562758803367614746094f, 0.00122839550022035837173f, 0.437942296266555786133f,
+                0.2576503753662109375f, 0.200372591614723205566f, 0.515525519847869873047f);
+
+            // Random scale.
+            var scale = new float3(0.235540181398391723633f, 0.215966641902923583984f, 0.533130943775177001953f);
+            var actual = math.mulScale(m, scale);
+            var expected = new float3x3(
+                0.210036873817443847656f, 0.0337378568947315216064f, 0.262439817190170288086f,
+                0.132552310824394226074f, 0.000265292444964870810509f, 0.233480587601661682129f,
+                0.0606870166957378387451f, 0.043273795396089553833f, 0.274842619895935058594f);
+
+            TestUtils.AreEqual(expected, actual, 1e-5);
+        }
+
+        [TestCompiler]
+        public static void scaleMul()
+        {
+            var tolerance = 1e-5f;
+
+            // Random matrix, same as in mulScale test.
+            var m = new float3x3(
+                0.891724169254302978516f, 0.156217902898788452148f, 0.492261469364166259766f,
+                0.562758803367614746094f, 0.00122839550022035837173f, 0.437942296266555786133f,
+                0.2576503753662109375f, 0.200372591614723205566f, 0.515525519847869873047f);
+
+            // Random scale, same as in mulScale test.
+            var scale = new float3(0.235540181398391723633f, 0.215966641902923583984f, 0.533130943775177001953f);
+            var actual = math.scaleMul(scale, m);
+            var expected = new float3x3(
+                0.210036873817443847656f, 0.0367955937981605529785f, 0.115947358310222625732f,
+                0.121537126600742340088f, 0.000265292444964870810509f, 0.0945809260010719299316f,
+                0.137361392378807067871f, 0.106824830174446105957f, 0.274842619895935058594f);
+
+            TestUtils.AreEqual(expected, actual, tolerance);
         }
     }
 }
diff --git a/src/Tests/Tests/Shared/TestSvd.cs b/src/Tests/Tests/Shared/TestSvd.cs
index d66c4968..f5ae195c 100644
--- a/src/Tests/Tests/Shared/TestSvd.cs
+++ b/src/Tests/Tests/Shared/TestSvd.cs
@@ -147,7 +147,7 @@ public static void CanSVDInverseFloat3x3With_LinearDependentRow()
         public static void CanSVDInverseFloat3x3With_RotatedZeroScale()
         {
             var m102030 = math.float3x3(quaternion.Euler(math.radians(10f), math.radians(20f), math.radians(30f)));
-            var parent  = svd.mulScale(m102030, math.float3(1f, 1f, 0f));
+            var parent  = math.mulScale(m102030, math.float3(1f, 1f, 0f));
             var mat     = math.mul(parent, m102030);
 
             ValidateSingular(mat);
@@ -175,55 +175,11 @@ public static void CanExtractSVDRotationFromFloat3x3With_ZeroScaleXY()
         {
             var q0 = quaternion.Euler(math.radians(10f), math.radians(20f), math.radians(30f));
             var m0 = math.float3x3(q0);
-            var m0Scaled = svd.mulScale(m0, math.float3(1f, 0f, 0f));
+            var m0Scaled = math.mulScale(m0, math.float3(1f, 0f, 0f));
             var q1 = svd.svdRotation(m0Scaled);
             var m1 = math.float3x3(q1);
 
             TestUtils.AreEqual(0.0f, math.length(m0.c0 - m1.c0), k_SVDTolerance);
         }
-
-        [TestCompiler]
-        public static void mulScale()
-        {
-            var tolerance = 1e-5f;
-
-            // Random matrix.
-            var m = new float3x3(
-                0.891724169254302978516f, 0.156217902898788452148f, 0.492261469364166259766f,
-                0.562758803367614746094f, 0.00122839550022035837173f, 0.437942296266555786133f,
-                0.2576503753662109375f, 0.200372591614723205566f, 0.515525519847869873047f);
-
-            // Random scale.
-            var scale = new float3(0.235540181398391723633f, 0.215966641902923583984f, 0.533130943775177001953f);
-            var actual = svd.mulScale(m, scale);
-            var expected = new float3x3(
-                0.210036873817443847656f, 0.0337378568947315216064f, 0.262439817190170288086f,
-                0.132552310824394226074f, 0.000265292444964870810509f, 0.233480587601661682129f,
-                0.0606870166957378387451f, 0.043273795396089553833f, 0.274842619895935058594f);
-
-            TestUtils.AreEqual(expected, actual, 1e-5);
-        }
-
-        [TestCompiler]
-        public static void scaleMul()
-        {
-            var tolerance = 1e-5f;
-
-            // Random matrix, same as in mulScale test.
-            var m = new float3x3(
-                0.891724169254302978516f, 0.156217902898788452148f, 0.492261469364166259766f,
-                0.562758803367614746094f, 0.00122839550022035837173f, 0.437942296266555786133f,
-                0.2576503753662109375f, 0.200372591614723205566f, 0.515525519847869873047f);
-
-            // Random scale, same as in mulScale test.
-            var scale = new float3(0.235540181398391723633f, 0.215966641902923583984f, 0.533130943775177001953f);
-            var actual = svd.scaleMul(scale, m);
-            var expected = new float3x3(
-                0.210036873817443847656f, 0.0367955937981605529785f, 0.115947358310222625732f,
-                0.121537126600742340088f, 0.000265292444964870810509f, 0.0945809260010719299316f,
-                0.137361392378807067871f, 0.106824830174446105957f, 0.274842619895935058594f);
-
-            TestUtils.AreEqual(expected, actual, tolerance);
-        }
     }
 }
\ No newline at end of file
diff --git a/src/Unity.Mathematics/math.cs b/src/Unity.Mathematics/math.cs
index 016cc971..f2d1b285 100644
--- a/src/Unity.Mathematics/math.cs
+++ b/src/Unity.Mathematics/math.cs
@@ -7017,6 +7017,30 @@ public static float3 Euler(quaternion q, math.RotationOrder order = math.Rotatio
             }
         }
 
+        /// <summary>
+        /// Matrix columns multiplied by scale components
+        /// m.c0.x * s.x | m.c1.x * s.y | m.c2.x * s.z
+        /// m.c0.y * s.x | m.c1.y * s.y | m.c2.y * s.z
+        /// m.c0.z * s.x | m.c1.z * s.y | m.c2.z * s.z
+        /// </summary>
+        /// <param name="m">Matrix to scale.</param>
+        /// <param name="s">Scaling coefficients for each column.</param>
+        /// <returns>The scaled matrix.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3x3 mulScale(float3x3 m, float3 s) => new float3x3(m.c0 * s.x, m.c1 * s.y, m.c2 * s.z);
+
+        /// <summary>
+        /// Matrix rows multiplied by scale components
+        /// m.c0.x * s.x | m.c1.x * s.x | m.c2.x * s.x
+        /// m.c0.y * s.y | m.c1.y * s.y | m.c2.y * s.y
+        /// m.c0.z * s.z | m.c1.z * s.z | m.c2.z * s.z
+        /// </summary>
+        /// <param name="s">Scaling coefficients for each row.</param>
+        /// <param name="m">Matrix to scale.</param>
+        /// <returns>The scaled matrix.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3x3 scaleMul(float3 s, float3x3 m) => new float3x3(m.c0 * s, m.c1 * s, m.c2 * s);
+
         // Internal
 
         // SSE shuffles
diff --git a/src/Unity.Mathematics/matrix.cs b/src/Unity.Mathematics/matrix.cs
index 6589eb1b..449c7e36 100644
--- a/src/Unity.Mathematics/matrix.cs
+++ b/src/Unity.Mathematics/matrix.cs
@@ -1103,13 +1103,13 @@ public static float3x3 pseudoinverse(float3x3 m)
                 return Mathematics.float3x3.zero;
 
             float3 scaleInv = math.rsqrt(scaleSq);
-            float3x3 ms = svd.mulScale(m, scaleInv);
+            float3x3 ms = mulScale(m, scaleInv);
             if (!adjInverse(ms, out float3x3 i, svd.k_EpsilonDeterminant))
             {
                 i = svd.svdInverse(ms);
             }
 
-            return svd.mulScale(i, scaleInv);
+            return mulScale(i, scaleInv);
         }
     }
 }
diff --git a/src/Unity.Mathematics/quaternion.cs b/src/Unity.Mathematics/quaternion.cs
index 15007f7d..8eee529d 100644
--- a/src/Unity.Mathematics/quaternion.cs
+++ b/src/Unity.Mathematics/quaternion.cs
@@ -724,7 +724,7 @@ public static quaternion rotation(float3x3 m)
 
             if (math.abs(det) > svd.k_EpsilonDeterminant)
             {
-                float3x3 tmp = svd.mulScale(m, math.rsqrt(math.float3(math.lengthsq(m.c0), math.lengthsq(m.c1), math.lengthsq(m.c2))));
+                float3x3 tmp = mulScale(m, math.rsqrt(math.float3(math.lengthsq(m.c0), math.lengthsq(m.c1), math.lengthsq(m.c2))));
                 if (math.abs(1f - math.determinant(tmp)) < svd.k_EpsilonDeterminant)
                     return math.quaternion(tmp);
             }
@@ -750,7 +750,7 @@ static bool adjInverse(float3x3 m, out float3x3 i, float epsilon = svd.k_Epsilon
             i = adj(m, out float det);
             bool c = math.abs(det) > epsilon;
             float3 detInv = math.select(math.float3(1f), math.rcp(det), c);
-            i = svd.scaleMul(detInv, i);
+            i = scaleMul(detInv, i);
             return c;
         }
 
diff --git a/src/Unity.Mathematics/svd.cs b/src/Unity.Mathematics/svd.cs
index 2ff93d38..b0a32112 100644
--- a/src/Unity.Mathematics/svd.cs
+++ b/src/Unity.Mathematics/svd.cs
@@ -7,7 +7,7 @@ namespace Unity.Mathematics
     // Computing the singular value decomposition of 3x3 matrices with minimal branching and elementary floating point operations,
     // A.McAdams, A.Selle, R.Tamstorf, J.Teran and E.Sifakis, University of Wisconsin - Madison technical report TR1690, May 2011
     [Il2CppEagerStaticClassConstruction]
-    class svd
+    static class svd
     {
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static void condSwap(bool c, ref float x, ref float y)
@@ -146,24 +146,6 @@ static float3 singularValuesDecomposition(float3x3 a, out quaternion u, out quat
         public const float k_EpsilonNormalSqrt = 1e-15f;
         public const float k_EpsilonNormal = 1e-30f;
 
-        /// <summary>
-        /// Matrix columns multiplied by scale components
-        /// m.c0.x * s.x | m.c1.x * s.y | m.c2.x * s.z
-        /// m.c0.y * s.x | m.c1.y * s.y | m.c2.y * s.z
-        /// m.c0.z * s.x | m.c1.z * s.y | m.c2.z * s.z
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3x3 mulScale(float3x3 m, float3 s) => new float3x3(m.c0 * s.x, m.c1 * s.y, m.c2 * s.z);
-
-        /// <summary>
-        /// Matrix rows multiplied by scale components
-        /// m.c0.x * s.x | m.c1.x * s.x | m.c2.x * s.x
-        /// m.c0.y * s.y | m.c1.y * s.y | m.c2.y * s.y
-        /// m.c0.z * s.z | m.c1.z * s.z | m.c2.z * s.z
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3x3 scaleMul(float3 s, float3x3 m) => new float3x3(m.c0 * s, m.c1 * s, m.c2 * s);
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static float3 rcpsafe(float3 x, float epsilon = k_EpsilonRCP) =>
             math.select(math.rcp(x), float3.zero, math.abs(x) < epsilon);
@@ -175,7 +157,7 @@ internal static float3x3 svdInverse(float3x3 a)
             var um = math.float3x3(u);
             var vm = math.float3x3(v);
 
-            return math.mul(vm, scaleMul(rcpsafe(e, k_EpsilonDeterminant), math.transpose(um)));
+            return math.mul(vm, math.scaleMul(rcpsafe(e, k_EpsilonDeterminant), math.transpose(um)));
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

From 9073b5bd683e0f80951136ee19f30a1739461346 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Wed, 19 Jan 2022 16:17:39 -0800
Subject: [PATCH 35/94] Update changelog to reflect code movement.

---
 src/CHANGELOG.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index 2427dc67..46c7a0e3 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -9,8 +9,8 @@
 * Added `math.Euler` to convert a quaternion to Euler angles.
 * Added `math.angle` to compute the angle between two unit quaternions.
 * Added `math.rotation` to extract a quaternion rotation from a float3x3 (that may have scale).
-* Added `svd.mulScale` to scale columns of a float3x3 with scaling coefficients in a float3.
-* Added `svd.scaleMul` to scale rows of a float3x3 with scaling coefficients in a float3.
+* Added `math.mulScale` to scale columns of a float3x3 with scaling coefficients in a float3.
+* Added `math.scaleMul` to scale rows of a float3x3 with scaling coefficients in a float3.
 ### Changed
 * `asfloat(uint)`, `asuint(float)`, `asint(float)` and other related methods are now faster in mono without Burst. Other methods which use these will see a performance improvement.
 * Modified `quaternion.nlerp` to be branchless.

From 9439a38b463fc3e8f1f6ec20ae6c6449fcaed462 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Wed, 19 Jan 2022 16:19:44 -0800
Subject: [PATCH 36/94] Whitespace fix.

---
 src/Tests/Tests/Shared/TestMath.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Tests/Tests/Shared/TestMath.cs b/src/Tests/Tests/Shared/TestMath.cs
index 6f5c03f9..1c42283a 100644
--- a/src/Tests/Tests/Shared/TestMath.cs
+++ b/src/Tests/Tests/Shared/TestMath.cs
@@ -4079,7 +4079,7 @@ static quaternion TestRefEulerToQuat(float3 angle, math.RotationOrder order)
             }
         }
 
-                [TestCompiler]
+        [TestCompiler]
         public static void mulScale()
         {
             var tolerance = 1e-5f;

From a4829f42138969e38b339e4bc4d78e06ae0a2ece Mon Sep 17 00:00:00 2001
From: Olivier Dionne <olivierd@unity3d.com>
Date: Thu, 20 Jan 2022 12:55:45 -0500
Subject: [PATCH 37/94] Fix merge conflict

---
 src/Unity.Mathematics/affine_transform.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Unity.Mathematics/affine_transform.cs b/src/Unity.Mathematics/affine_transform.cs
index 5b07fa7a..33567b92 100644
--- a/src/Unity.Mathematics/affine_transform.cs
+++ b/src/Unity.Mathematics/affine_transform.cs
@@ -42,7 +42,7 @@ public AffineTransform(float3 translation, quaternion rotation)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public AffineTransform(float3 translation, quaternion rotation, float3 scale)
         {
-            rs = svd.mulScale(math.float3x3(rotation), scale);
+            rs = mulScale(math.float3x3(rotation), scale);
             t = translation;
         }
 

From 8fd17c4cb61024f2263992d83be3d0cdfae47862 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Tue, 25 Jan 2022 15:47:14 -0800
Subject: [PATCH 38/94] Copy SVD implementation from Unity.Animation (#210)

---
 src/CHANGELOG.md                              |   3 +
 src/Tests/Tests/Shared/TestMath.cs            |  44 +++++
 src/Tests/Tests/Shared/TestMatrix.cs          |  41 ++++
 src/Tests/Tests/Shared/TestQuaternion.cs      |  80 ++++++++
 src/Tests/Tests/Shared/TestSvd.cs             | 185 ++++++++++++++++++
 src/Tests/Tests/Shared/TestSvd.cs.meta        |  11 ++
 src/Tests/Unity.Mathematics.Tests.csproj      |   2 +
 .../VectorGenerator.cs                        |   3 +
 .../TestInverse.gen.cs                        |  84 ++++++++
 .../Unity.Mathematics.csproj                  |   1 +
 src/Unity.Mathematics/math.cs                 |  24 +++
 src/Unity.Mathematics/matrix.cs               |  22 +++
 src/Unity.Mathematics/quaternion.cs           |  46 ++++-
 src/Unity.Mathematics/svd.cs                  | 170 ++++++++++++++++
 src/Unity.Mathematics/svd.cs.meta             |  11 ++
 15 files changed, 726 insertions(+), 1 deletion(-)
 create mode 100644 src/Tests/Tests/Shared/TestSvd.cs
 create mode 100644 src/Tests/Tests/Shared/TestSvd.cs.meta
 create mode 100644 src/Unity.Mathematics/svd.cs
 create mode 100644 src/Unity.Mathematics/svd.cs.meta

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index 9ca6b8dd..46c7a0e3 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -8,6 +8,9 @@
 * Added `math.chgsign` for float, float2, float3, and float4.
 * Added `math.Euler` to convert a quaternion to Euler angles.
 * Added `math.angle` to compute the angle between two unit quaternions.
+* Added `math.rotation` to extract a quaternion rotation from a float3x3 (that may have scale).
+* Added `math.mulScale` to scale columns of a float3x3 with scaling coefficients in a float3.
+* Added `math.scaleMul` to scale rows of a float3x3 with scaling coefficients in a float3.
 ### Changed
 * `asfloat(uint)`, `asuint(float)`, `asint(float)` and other related methods are now faster in mono without Burst. Other methods which use these will see a performance improvement.
 * Modified `quaternion.nlerp` to be branchless.
diff --git a/src/Tests/Tests/Shared/TestMath.cs b/src/Tests/Tests/Shared/TestMath.cs
index ee655b8a..1c42283a 100644
--- a/src/Tests/Tests/Shared/TestMath.cs
+++ b/src/Tests/Tests/Shared/TestMath.cs
@@ -4078,5 +4078,49 @@ static quaternion TestRefEulerToQuat(float3 angle, math.RotationOrder order)
                     return quaternion(float4(1f));
             }
         }
+
+        [TestCompiler]
+        public static void mulScale()
+        {
+            var tolerance = 1e-5f;
+
+            // Random matrix.
+            var m = new float3x3(
+                0.891724169254302978516f, 0.156217902898788452148f, 0.492261469364166259766f,
+                0.562758803367614746094f, 0.00122839550022035837173f, 0.437942296266555786133f,
+                0.2576503753662109375f, 0.200372591614723205566f, 0.515525519847869873047f);
+
+            // Random scale.
+            var scale = new float3(0.235540181398391723633f, 0.215966641902923583984f, 0.533130943775177001953f);
+            var actual = math.mulScale(m, scale);
+            var expected = new float3x3(
+                0.210036873817443847656f, 0.0337378568947315216064f, 0.262439817190170288086f,
+                0.132552310824394226074f, 0.000265292444964870810509f, 0.233480587601661682129f,
+                0.0606870166957378387451f, 0.043273795396089553833f, 0.274842619895935058594f);
+
+            TestUtils.AreEqual(expected, actual, 1e-5);
+        }
+
+        [TestCompiler]
+        public static void scaleMul()
+        {
+            var tolerance = 1e-5f;
+
+            // Random matrix, same as in mulScale test.
+            var m = new float3x3(
+                0.891724169254302978516f, 0.156217902898788452148f, 0.492261469364166259766f,
+                0.562758803367614746094f, 0.00122839550022035837173f, 0.437942296266555786133f,
+                0.2576503753662109375f, 0.200372591614723205566f, 0.515525519847869873047f);
+
+            // Random scale, same as in mulScale test.
+            var scale = new float3(0.235540181398391723633f, 0.215966641902923583984f, 0.533130943775177001953f);
+            var actual = math.scaleMul(scale, m);
+            var expected = new float3x3(
+                0.210036873817443847656f, 0.0367955937981605529785f, 0.115947358310222625732f,
+                0.121537126600742340088f, 0.000265292444964870810509f, 0.0945809260010719299316f,
+                0.137361392378807067871f, 0.106824830174446105957f, 0.274842619895935058594f);
+
+            TestUtils.AreEqual(expected, actual, tolerance);
+        }
     }
 }
diff --git a/src/Tests/Tests/Shared/TestMatrix.cs b/src/Tests/Tests/Shared/TestMatrix.cs
index 5bc45842..558ce482 100644
--- a/src/Tests/Tests/Shared/TestMatrix.cs
+++ b/src/Tests/Tests/Shared/TestMatrix.cs
@@ -1169,5 +1169,46 @@ public static void float3x3_from_float4x4_without_new()
 
             TestUtils.AreEqual(expected, float3x3(f4x4));
         }
+
+        [TestCompiler]
+        public static void float3x3_pseudoinverse_non_singular()
+        {
+            const float kTolerance = 1e-5f;
+
+            // A random 3x3 matrix, non-singular, generated from octave.
+            var a = new float3x3(
+                0.806710600852966308594f, 0.985506594181060791016f, 0.593669593334197998047f,
+                0.0869068726897239685059f, 0.754145503044128417969f, 0.222692146897315979004f,
+                0.917483031749725341797f, 0.443894535303115844727f, 0.138771042227745056152f);
+
+            // The regular inverse of a, as computed by octave.
+            var expected = new float3x3(
+                -0.0299495235085487365723f, -0.654392063617706298828f, 1.17825806140899658203f,
+                -0.992458224296569824219f, 2.23384380340576171875f, 0.661037027835845947266f,
+                3.37264156341552734375f, -2.81901407241821289063f, -2.69841933250427246094f);
+
+            TestUtils.AreEqual(expected, pseudoinverse(a), kTolerance);
+            TestUtils.AreEqual(expected, inverse(a), kTolerance);
+        }
+
+        [TestCompiler]
+        public static void float3x3_pseudoinverse_singular()
+        {
+            const float kTolerance = 1e-5f;
+
+            // A singular matrix.
+            var a = new float3x3(
+                0.0548239313066005706787f, 0.462397903203964233398f, 0.0501357726752758026123f,
+                0.0548239313066005706787f, 0.462397903203964233398f, 0.0501357726752758026123f,
+                0.938165545463562011719f, 0.542225778102874755859f, 0.10684439539909362793f);
+
+            // The pseudoinverse computed by octave.
+            var expected = new float3x3(
+                -0.675357639789581298828f, -0.675357699394226074219f, 1.14166188240051269531f,
+                1.15268361568450927734f, 1.15268361568450927734f, -0.140613287687301635742f,
+                0.0803283303976058959961f, 0.0803283303976058959961f, 0.0484490357339382171631f);
+
+            TestUtils.AreEqual(expected, pseudoinverse(a), kTolerance);
+        }
     }
 }
diff --git a/src/Tests/Tests/Shared/TestQuaternion.cs b/src/Tests/Tests/Shared/TestQuaternion.cs
index 5f531b0e..301725ee 100644
--- a/src/Tests/Tests/Shared/TestQuaternion.cs
+++ b/src/Tests/Tests/Shared/TestQuaternion.cs
@@ -380,5 +380,85 @@ public static void quaternion_angle()
             angle = math.angle(q, nq);
             TestUtils.AreEqual(0f, angle);
         }
+
+        [TestCompiler]
+        public static void quaternion_rotation_from_3x3_identity()
+        {
+            const float tolerance = 1e-5f;
+            var q = rotation(float3x3.identity);
+            TestUtils.AreEqual(quaternion.identity, q, tolerance);
+        }
+
+        [TestCompiler]
+        public static void quaternion_rotation_from_3x3_with_uniform_scale()
+        {
+            const float tolerance = 1e-5f;
+            var random = new Random(6173u);
+            var expectedQuaternion = random.NextQuaternionRotation();
+            var m = new float3x3(expectedQuaternion);
+            m = mul(m, float3x3.Scale(5.18f));
+            var actualQuaternion = rotation(m);
+            TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
+        }
+
+        [TestCompiler]
+        public static void quaternion_rotation_from_3x3_with_nonuniform_scale()
+        {
+            const float tolerance = 1e-5f;
+            var m = new float3x3(
+                2.0f, 0.0f, 0.0f,
+                0.0f, 1.5f, 0.0f,
+                0.0f, 0.0f, 3.1f);
+            var q = rotation(m);
+            TestUtils.AreEqual(quaternion.identity, q, tolerance);
+        }
+
+        [TestCompiler]
+        public static void quaternion_rotation_from_3x3_with_negative_scale_x()
+        {
+            const float tolerance = 1e-5f;
+            var random = new Random(281u);
+            var expectedQuaternion = random.NextQuaternionRotation();
+            var m = new float3x3(expectedQuaternion);
+            m = mul(m, float3x3.Scale(-1.5f, 0.2f, 51.281f));
+            var actualQuaternion = rotation(m);
+            TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
+        }
+
+        [TestCompiler]
+        public static void quaternion_rotation_from_3x3_with_negative_scale_y()
+        {
+            const float tolerance = 1e-5f;
+            var random = new Random(10000u);
+            var expectedQuaternion = random.NextQuaternionRotation();
+            var m = new float3x3(expectedQuaternion);
+            m = mul(m, float3x3.Scale(1.5f, -0.2f, 51.281f));
+            var actualQuaternion = rotation(m);
+            TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
+        }
+
+        [TestCompiler]
+        public static void quaternion_rotation_from_3x3_with_negative_scale_z()
+        {
+            const float tolerance = 1e-5f;
+            var random = new Random(9891712u);
+            var expectedQuaternion = random.NextQuaternionRotation();
+            var m = new float3x3(expectedQuaternion);
+            m = mul(m, float3x3.Scale(1.5f, 0.2f, -51.281f));
+            var actualQuaternion = rotation(m);
+            TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
+        }
+
+        [TestCompiler]
+        public static void quaternion_rotation_from_3x3_with_negative_nonuniform_scale()
+        {
+            const float tolerance = 1e-5f;
+            var random = new Random(912u);
+            var expectedQuaternion = random.NextQuaternionRotation();
+            var m = new float3x3(expectedQuaternion);
+            m = mul(m, float3x3.Scale(-1.5f, -0.2f, -51.281f));
+            var actualQuaternion = rotation(m);
+            TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
+        }
     }
 }
diff --git a/src/Tests/Tests/Shared/TestSvd.cs b/src/Tests/Tests/Shared/TestSvd.cs
new file mode 100644
index 00000000..f5ae195c
--- /dev/null
+++ b/src/Tests/Tests/Shared/TestSvd.cs
@@ -0,0 +1,185 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    public class TestSvd
+    {
+        const float k_SVDTolerance = 1e-4f;
+
+        static bool QuaternionEquals(quaternion expected, quaternion actual, float tolerance) =>
+            (math.lengthsq(expected) == 0f && math.lengthsq(actual) == 0f) || math.abs(math.dot(expected, actual)) > (1f - tolerance);
+
+        // Validate Penrose condition that [aba = a]
+        static void ValidatePenrose1(in float3x3 a, in float3x3 b)
+        {
+            var testA = math.mul(math.mul(a, b), a);
+
+            TestUtils.AreEqual(a.c0.x, testA.c0.x, k_SVDTolerance);
+            TestUtils.AreEqual(a.c0.y, testA.c0.y, k_SVDTolerance);
+            TestUtils.AreEqual(a.c0.z, testA.c0.z, k_SVDTolerance);
+            TestUtils.AreEqual(a.c1.x, testA.c1.x, k_SVDTolerance);
+            TestUtils.AreEqual(a.c1.y, testA.c1.y, k_SVDTolerance);
+            TestUtils.AreEqual(a.c1.z, testA.c1.z, k_SVDTolerance);
+            TestUtils.AreEqual(a.c2.x, testA.c2.x, k_SVDTolerance);
+            TestUtils.AreEqual(a.c2.y, testA.c2.y, k_SVDTolerance);
+            TestUtils.AreEqual(a.c2.z, testA.c2.z, k_SVDTolerance);
+        }
+
+        // Validate Penrose condition that [transpose(ab) = ab]
+        static void ValidatePenrose2(in float3x3 a, in float3x3 b)
+        {
+            var ab = math.mul(a, b);
+            var testAB = math.transpose(ab);
+
+            TestUtils.AreEqual(ab.c0.x, testAB.c0.x, k_SVDTolerance);
+            TestUtils.AreEqual(ab.c0.y, testAB.c0.y, k_SVDTolerance);
+            TestUtils.AreEqual(ab.c0.z, testAB.c0.z, k_SVDTolerance);
+            TestUtils.AreEqual(ab.c1.x, testAB.c1.x, k_SVDTolerance);
+            TestUtils.AreEqual(ab.c1.y, testAB.c1.y, k_SVDTolerance);
+            TestUtils.AreEqual(ab.c1.z, testAB.c1.z, k_SVDTolerance);
+            TestUtils.AreEqual(ab.c2.x, testAB.c2.x, k_SVDTolerance);
+            TestUtils.AreEqual(ab.c2.y, testAB.c2.y, k_SVDTolerance);
+            TestUtils.AreEqual(ab.c2.z, testAB.c2.z, k_SVDTolerance);
+        }
+
+        static void ValidateSingular(in float3x3 a) =>
+            TestUtils.AreEqual(0.0f, math.determinant(a), k_SVDTolerance);
+
+        [TestCompiler]
+        public static void CanSVDInverseNonSingularFloat3x3()
+        {
+            var mat = math.float3x3(
+                math.float3(9f, 1f, 2f),
+                math.float3(3f, 8f, 4f),
+                math.float3(5f, 6f, 7f)
+            );
+
+            var inv = svd.svdInverse(mat);
+            var testIdentity = math.mul(mat, inv);
+
+            TestUtils.AreEqual(1f, testIdentity.c0.x, k_SVDTolerance);
+            TestUtils.AreEqual(0f, testIdentity.c0.y, k_SVDTolerance);
+            TestUtils.AreEqual(0f, testIdentity.c0.z, k_SVDTolerance);
+            TestUtils.AreEqual(0f, testIdentity.c1.x, k_SVDTolerance);
+            TestUtils.AreEqual(1f, testIdentity.c1.y, k_SVDTolerance);
+            TestUtils.AreEqual(0f, testIdentity.c1.z, k_SVDTolerance);
+            TestUtils.AreEqual(0f, testIdentity.c2.x, k_SVDTolerance);
+            TestUtils.AreEqual(0f, testIdentity.c2.y, k_SVDTolerance);
+            TestUtils.AreEqual(1f, testIdentity.c2.z, k_SVDTolerance);
+        }
+
+        [TestCompiler]
+        public static void CanSVDInverseFloat3x3With_NullColumn()
+        {
+            var mat = math.float3x3(
+                math.float3(9f, 1f, 0f),
+                math.float3(3f, 8f, 0f),
+                math.float3(5f, 6f, 0f)
+            );
+
+            ValidateSingular(mat);
+            var inv = svd.svdInverse(mat);
+
+            ValidatePenrose1(mat, inv);
+            ValidatePenrose1(inv, mat);
+            ValidatePenrose2(mat, inv);
+            ValidatePenrose2(inv, mat);
+        }
+
+        [TestCompiler]
+        public static void CanSVDInverseFloat3x3With_NullRow()
+        {
+            var mat = math.float3x3(
+                math.float3(9f, 1f, 2f),
+                math.float3(0f, 0f, 0f),
+                math.float3(5f, 6f, 7f)
+            );
+
+            ValidateSingular(mat);
+            var inv = svd.svdInverse(mat);
+
+            ValidatePenrose1(mat, inv);
+            ValidatePenrose1(inv, mat);
+            ValidatePenrose2(mat, inv);
+            ValidatePenrose2(inv, mat);
+        }
+
+        [TestCompiler]
+        public static void CanSVDInverseFloat3x3With_LinearDependentColumn()
+        {
+            var mat = math.float3x3(
+                math.float3(9f, 4f, 2f),
+                math.float3(3f, 8f, 4f),
+                math.float3(5f, 14f, 7f)
+            );
+
+            ValidateSingular(mat);
+            var inv = svd.svdInverse(mat);
+
+            ValidatePenrose1(mat, inv);
+            ValidatePenrose1(inv, mat);
+            ValidatePenrose2(mat, inv);
+            ValidatePenrose2(inv, mat);
+        }
+
+        [TestCompiler]
+        public static void CanSVDInverseFloat3x3With_LinearDependentRow()
+        {
+            var mat = math.float3x3(
+                math.float3(9f, 1f, 2f),
+                math.float3(10f, 12f, 14f),
+                math.float3(5f, 6f, 7f)
+            );
+
+            ValidateSingular(mat);
+            var inv = svd.svdInverse(mat);
+
+            ValidatePenrose1(mat, inv);
+            ValidatePenrose1(inv, mat);
+            ValidatePenrose2(mat, inv);
+            ValidatePenrose2(inv, mat);
+        }
+
+        [TestCompiler]
+        public static void CanSVDInverseFloat3x3With_RotatedZeroScale()
+        {
+            var m102030 = math.float3x3(quaternion.Euler(math.radians(10f), math.radians(20f), math.radians(30f)));
+            var parent  = math.mulScale(m102030, math.float3(1f, 1f, 0f));
+            var mat     = math.mul(parent, m102030);
+
+            ValidateSingular(mat);
+            var inv = svd.svdInverse(mat);
+
+            ValidatePenrose1(mat, inv);
+            ValidatePenrose1(inv, mat);
+            ValidatePenrose2(mat, inv);
+            ValidatePenrose2(inv, mat);
+        }
+
+        // Case 928598: The errors appear, when GameObject has a child with ParticleSystem which is rotated along the y-axis to -180 and is moved
+        [TestCompiler]
+        public static void CanExtractSVDRotationFromFloat3x3With_X180_Y0_Z181()
+        {
+            var q = quaternion.Euler(math.radians(180f), math.radians(0f), math.radians(181f));
+            var qSVD = svd.svdRotation(math.float3x3(q));
+
+            TestUtils.IsTrue(QuaternionEquals(q, qSVD, k_SVDTolerance));
+        }
+
+        // Case 938548: Assertion failed on expression: 'CompareApproximately(det, 1.0F, .005f)' when scaling system to 0 on at least 2 axes
+        [TestCompiler]
+        public static void CanExtractSVDRotationFromFloat3x3With_ZeroScaleXY()
+        {
+            var q0 = quaternion.Euler(math.radians(10f), math.radians(20f), math.radians(30f));
+            var m0 = math.float3x3(q0);
+            var m0Scaled = math.mulScale(m0, math.float3(1f, 0f, 0f));
+            var q1 = svd.svdRotation(m0Scaled);
+            var m1 = math.float3x3(q1);
+
+            TestUtils.AreEqual(0.0f, math.length(m0.c0 - m1.c0), k_SVDTolerance);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Tests/Tests/Shared/TestSvd.cs.meta b/src/Tests/Tests/Shared/TestSvd.cs.meta
new file mode 100644
index 00000000..824a25f5
--- /dev/null
+++ b/src/Tests/Tests/Shared/TestSvd.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8218cb7d87dac4432871cd5bd00fd333
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/src/Tests/Unity.Mathematics.Tests.csproj b/src/Tests/Unity.Mathematics.Tests.csproj
index 4ca36bde..d6fe8748 100644
--- a/src/Tests/Unity.Mathematics.Tests.csproj
+++ b/src/Tests/Unity.Mathematics.Tests.csproj
@@ -12,6 +12,7 @@
     <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <TargetFrameworkProfile />
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -106,6 +107,7 @@
     <Compile Include="Tests\Shared\TestPlane.cs" />
     <Compile Include="Tests\Shared\TestQuaternion.cs" />
     <Compile Include="Tests\Shared\TestRigidTransform.cs" />
+    <Compile Include="Tests\Shared\TestSvd.cs" />
     <Compile Include="Tests\TestMath2.cs" />
     <Compile Include="Tests\TestRandom.cs" />
     <Compile Include="Tests\Shared\TestUint2.gen.cs" />
diff --git a/src/Unity.Mathematics.CodeGen/VectorGenerator.cs b/src/Unity.Mathematics.CodeGen/VectorGenerator.cs
index 87f7fbb0..a6c203b3 100644
--- a/src/Unity.Mathematics.CodeGen/VectorGenerator.cs
+++ b/src/Unity.Mathematics.CodeGen/VectorGenerator.cs
@@ -3224,6 +3224,9 @@ void GenerateInversePerformanceTests(StringBuilder str)
             GeneratePerformanceTest(str, "quaternion_inverse", new PerformanceTestArrayArgument[] {
                 new PerformanceTestArrayArgument { m_ElementType = "quaternion", m_MemberName = "q", m_ElementInitializer = "quaternion.identity" },
             }, "args.q[i] = math.inverse(args.q[i]);", 10000);
+            GeneratePerformanceTest(str, "pseudoinverse", new PerformanceTestArrayArgument[] {
+                new PerformanceTestArrayArgument { m_ElementType = "float3x3", m_MemberName = "m", m_ElementInitializer = "new float3x3(0.054824f, 0.462398f, 0.050136f, 0.054824f, 0.462398f, 0.050136f, 0.938166f, 0.542226f, 0.106844f)" },
+            }, "args.m[i] = math.pseudoinverse(args.m[i]);", 1000);
 
             EndPerformanceTestCodeGen(str);
         }
diff --git a/src/Unity.Mathematics.PerformanceTests/TestInverse.gen.cs b/src/Unity.Mathematics.PerformanceTests/TestInverse.gen.cs
index 1359b2a3..26bfc7da 100644
--- a/src/Unity.Mathematics.PerformanceTests/TestInverse.gen.cs
+++ b/src/Unity.Mathematics.PerformanceTests/TestInverse.gen.cs
@@ -596,6 +596,90 @@ public void quaternion_inverse_burst()
             var args = new quaternion_inverse.Arguments();
             args.Init();
 
+            var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(burstSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+        [BurstCompile(CompileSynchronously = true)]
+        public unsafe class pseudoinverse
+        {
+            public const int iterations = 1000;
+
+            public struct Arguments : IDisposable
+            {
+                public Random rng;
+                public float3x3* m;
+
+                public void Init()
+                {
+                    rng = new Random(1);
+                    m = (float3x3*)UnsafeUtility.Malloc(UnsafeUtility.SizeOf<float3x3>() * iterations, UnsafeUtility.AlignOf<float3x3>(), Allocator.Persistent);
+                    for (int i = 0; i < iterations; ++i)
+                    {
+                        m[i] = new float3x3(0.054824f, 0.462398f, 0.050136f, 0.054824f, 0.462398f, 0.050136f, 0.938166f, 0.542226f, 0.106844f);
+                    }
+
+                }
+
+                public void Dispose()
+                {
+                    UnsafeUtility.Free(m, Allocator.Persistent);
+                }
+            }
+
+            public static void CommonTestFunction(ref Arguments args)
+            {
+                for (int i = 0; i < iterations; ++i)
+                {
+                    args.m[i] = math.pseudoinverse(args.m[i]);
+                }
+            }
+
+            public static void MonoTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            [BurstCompile(CompileSynchronously = true)]
+            public static void BurstTestFunction(ref Arguments args)
+            {
+                CommonTestFunction(ref args);
+            }
+
+            public delegate void TestFunction(ref Arguments args);
+        }
+
+        [Test, Performance]
+        public void pseudoinverse_mono()
+        {
+            pseudoinverse.TestFunction testFunction = pseudoinverse.MonoTestFunction;
+            var args = new pseudoinverse.Arguments();
+            args.Init();
+
+            var monoSampleGroup = new SampleGroup("Mono", SampleUnit.Microsecond);            Measure.Method(() =>
+            {
+                testFunction.Invoke(ref args);
+            })
+            .SampleGroup(monoSampleGroup)
+            .WarmupCount(1)
+            .MeasurementCount(10)
+            .Run();
+            args.Dispose();
+        }
+
+        [Test, Performance]
+        public void pseudoinverse_burst()
+        {
+            FunctionPointer<pseudoinverse.TestFunction> testFunction = BurstCompiler.CompileFunctionPointer<pseudoinverse.TestFunction>(pseudoinverse.BurstTestFunction);
+            var args = new pseudoinverse.Arguments();
+            args.Init();
+
             var burstSampleGroup = new SampleGroup("Burst", SampleUnit.Microsecond);            Measure.Method(() =>
             {
                 testFunction.Invoke(ref args);
diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj
index 11383fbb..da1856ac 100644
--- a/src/Unity.Mathematics/Unity.Mathematics.csproj
+++ b/src/Unity.Mathematics/Unity.Mathematics.csproj
@@ -138,6 +138,7 @@
     <Compile Include="quaternion.cs" />
     <Compile Include="rigid_transform.cs" />
     <Compile Include="random.cs" />
+    <Compile Include="svd.cs" />
     <Compile Include="uint2.gen.cs" />
     <Compile Include="uint2x2.gen.cs" />
     <Compile Include="uint2x3.gen.cs" />
diff --git a/src/Unity.Mathematics/math.cs b/src/Unity.Mathematics/math.cs
index 016cc971..f2d1b285 100644
--- a/src/Unity.Mathematics/math.cs
+++ b/src/Unity.Mathematics/math.cs
@@ -7017,6 +7017,30 @@ public static float3 Euler(quaternion q, math.RotationOrder order = math.Rotatio
             }
         }
 
+        /// <summary>
+        /// Matrix columns multiplied by scale components
+        /// m.c0.x * s.x | m.c1.x * s.y | m.c2.x * s.z
+        /// m.c0.y * s.x | m.c1.y * s.y | m.c2.y * s.z
+        /// m.c0.z * s.x | m.c1.z * s.y | m.c2.z * s.z
+        /// </summary>
+        /// <param name="m">Matrix to scale.</param>
+        /// <param name="s">Scaling coefficients for each column.</param>
+        /// <returns>The scaled matrix.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3x3 mulScale(float3x3 m, float3 s) => new float3x3(m.c0 * s.x, m.c1 * s.y, m.c2 * s.z);
+
+        /// <summary>
+        /// Matrix rows multiplied by scale components
+        /// m.c0.x * s.x | m.c1.x * s.x | m.c2.x * s.x
+        /// m.c0.y * s.y | m.c1.y * s.y | m.c2.y * s.y
+        /// m.c0.z * s.z | m.c1.z * s.z | m.c2.z * s.z
+        /// </summary>
+        /// <param name="s">Scaling coefficients for each row.</param>
+        /// <param name="m">Matrix to scale.</param>
+        /// <returns>The scaled matrix.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3x3 scaleMul(float3 s, float3x3 m) => new float3x3(m.c0 * s, m.c1 * s, m.c2 * s);
+
         // Internal
 
         // SSE shuffles
diff --git a/src/Unity.Mathematics/matrix.cs b/src/Unity.Mathematics/matrix.cs
index fe4a679c..449c7e36 100644
--- a/src/Unity.Mathematics/matrix.cs
+++ b/src/Unity.Mathematics/matrix.cs
@@ -1089,5 +1089,27 @@ public static float3x3 orthonormalize(float3x3 i)
 
             return o;
         }
+
+        /// <summary>
+        /// Computes the pseudoinverse of a matrix.
+        /// </summary>
+        /// <param name="m">Matrix to invert.</param>
+        /// <returns>The pseudoinverse of m.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float3x3 pseudoinverse(float3x3 m)
+        {
+            float scaleSq = 0.333333f * (math.lengthsq(m.c0) + math.lengthsq(m.c1) + math.lengthsq(m.c2));
+            if (scaleSq < svd.k_EpsilonNormal)
+                return Mathematics.float3x3.zero;
+
+            float3 scaleInv = math.rsqrt(scaleSq);
+            float3x3 ms = mulScale(m, scaleInv);
+            if (!adjInverse(ms, out float3x3 i, svd.k_EpsilonDeterminant))
+            {
+                i = svd.svdInverse(ms);
+            }
+
+            return mulScale(i, scaleInv);
+        }
     }
 }
diff --git a/src/Unity.Mathematics/quaternion.cs b/src/Unity.Mathematics/quaternion.cs
index 3c09d991..b013fd24 100644
--- a/src/Unity.Mathematics/quaternion.cs
+++ b/src/Unity.Mathematics/quaternion.cs
@@ -710,6 +710,51 @@ public static float angle(quaternion q1, quaternion q2)
             return diff + diff;
         }
 
+        /// <summary>
+        /// Extracts the rotation from a matrix.
+        /// </summary>
+        /// <remarks>This method supports any type of rotation matrix: if the matrix has a non uniform scale you should use this method.</remarks>
+        /// <param name="m">Matrix to extract rotation from</param>
+        /// <returns>Extracted rotation</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static quaternion rotation(float3x3 m)
+        {
+            float det = math.determinant(m);
+            if (math.abs(1f - det) < svd.k_EpsilonDeterminant)
+                return math.quaternion(m);
+
+            if (math.abs(det) > svd.k_EpsilonDeterminant)
+            {
+                float3x3 tmp = mulScale(m, math.rsqrt(math.float3(math.lengthsq(m.c0), math.lengthsq(m.c1), math.lengthsq(m.c2))));
+                if (math.abs(1f - math.determinant(tmp)) < svd.k_EpsilonDeterminant)
+                    return math.quaternion(tmp);
+            }
+
+            return svd.svdRotation(m);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static float3x3 adj(float3x3 m, out float det)
+        {
+            float3x3 adjT;
+            adjT.c0 = math.cross(m.c1, m.c2);
+            adjT.c1 = math.cross(m.c2, m.c0);
+            adjT.c2 = math.cross(m.c0, m.c1);
+            det = math.dot(m.c0, adjT.c0);
+
+            return math.transpose(adjT);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static bool adjInverse(float3x3 m, out float3x3 i, float epsilon = svd.k_EpsilonNormal)
+        {
+            i = adj(m, out float det);
+            bool c = math.abs(det) > epsilon;
+            float3 detInv = math.select(math.float3(1f), math.rcp(det), c);
+            i = scaleMul(detInv, i);
+            return c;
+        }
+
         /// <summary>Returns a uint hash code of a quaternion.</summary>
         /// <param name="q">The quaternion to hash.</param>
         /// <returns>The hash code for the input quaternion.</returns>
@@ -732,7 +777,6 @@ public static uint4 hashwide(quaternion q)
             return hashwide(q.value);
         }
 
-
         /// <summary>
         /// Transforms the forward vector by a quaternion.
         /// </summary>
diff --git a/src/Unity.Mathematics/svd.cs b/src/Unity.Mathematics/svd.cs
new file mode 100644
index 00000000..b0a32112
--- /dev/null
+++ b/src/Unity.Mathematics/svd.cs
@@ -0,0 +1,170 @@
+using System.Runtime.CompilerServices;
+using Unity.IL2CPP.CompilerServices;
+
+namespace Unity.Mathematics
+{
+    // SVD algorithm as described in:
+    // Computing the singular value decomposition of 3x3 matrices with minimal branching and elementary floating point operations,
+    // A.McAdams, A.Selle, R.Tamstorf, J.Teran and E.Sifakis, University of Wisconsin - Madison technical report TR1690, May 2011
+    [Il2CppEagerStaticClassConstruction]
+    static class svd
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void condSwap(bool c, ref float x, ref float y)
+        {
+            var tmp = x;
+            x = math.select(x, y, c);
+            y = math.select(y, tmp, c);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void condNegSwap(bool c, ref float3 x, ref float3 y)
+        {
+            var tmp = -x;
+            x = math.select(x, y, c);
+            y = math.select(y, tmp, c);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static quaternion condNegSwapQuat(bool c, quaternion q, float4 mask)
+        {
+            const float halfSqrt2 = 0.707106781186548f;
+            return math.mul(q, math.select(quaternion.identity.value, mask * halfSqrt2, c));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static void sortSingularValues(ref float3x3 b, ref quaternion v)
+        {
+            var l0 = math.lengthsq(b.c0);
+            var l1 = math.lengthsq(b.c1);
+            var l2 = math.lengthsq(b.c2);
+
+            var c = l0 < l1;
+            condNegSwap(c, ref b.c0, ref b.c1);
+            v = condNegSwapQuat(c, v, math.float4(0f, 0f, 1f, 1f));
+            condSwap(c, ref l0, ref l1);
+
+            c = l0 < l2;
+            condNegSwap(c, ref b.c0, ref b.c2);
+            v = condNegSwapQuat(c, v, math.float4(0f, -1f, 0f, 1f));
+            condSwap(c, ref l0, ref l2);
+
+            c = l1 < l2;
+            condNegSwap(c, ref b.c1, ref b.c2);
+            v = condNegSwapQuat(c, v, math.float4(1f, 0f, 0f, 1f));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static quaternion approxGivensQuat(float3 pq, float4 mask)
+        {
+            const float c8 = 0.923879532511287f; // cos(pi/8)
+            const float s8 = 0.38268343236509f; // sin(pi/8)
+            const float g = 5.82842712474619f; // 3 + 2 * sqrt(2)
+
+            var ch = 2f * (pq.x - pq.y); // approx cos(a/2)
+            var sh = pq.z; // approx sin(a/2)
+            var r = math.select(math.float4(s8, s8, s8, c8), math.float4(sh, sh, sh, ch), g * sh * sh < ch * ch) * mask;
+            return math.normalize(r);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static quaternion qrGivensQuat(float2 pq, float4 mask)
+        {
+            var l = math.sqrt(pq.x * pq.x + pq.y * pq.y);
+            var sh = math.select(0f, pq.y, l > k_EpsilonNormalSqrt);
+            var ch = math.abs(pq.x) + math.max(l, k_EpsilonNormalSqrt);
+            condSwap(pq.x < 0f, ref sh, ref ch);
+
+            return math.normalize(math.float4(sh, sh, sh, ch) * mask);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static quaternion givensQRFactorization(float3x3 b, out float3x3 r)
+        {
+            var u = qrGivensQuat(math.float2(b.c0.x, b.c0.y), math.float4(0f, 0f, 1f, 1f));
+            var qmt = math.float3x3(math.conjugate(u));
+            r = math.mul(qmt, b);
+
+            var q = qrGivensQuat(math.float2(r.c0.x, r.c0.z), math.float4(0f, -1f, 0f, 1f));
+            u = math.mul(u, q);
+            qmt = math.float3x3(math.conjugate(q));
+            r = math.mul(qmt, r);
+
+            q = qrGivensQuat(math.float2(r.c1.y, r.c1.z), math.float4(1f, 0f, 0f, 1f));
+            u = math.mul(u, q);
+            qmt = math.float3x3(math.conjugate(q));
+            r = math.mul(qmt, r);
+
+            return u;
+        }
+
+        static quaternion jacobiIteration(ref float3x3 s, int iterations = 5)
+        {
+            float3x3 qm;
+            quaternion q;
+            quaternion v = quaternion.identity;
+
+            for (int i = 0; i < iterations; ++i)
+            {
+                q = approxGivensQuat(math.float3(s.c0.x, s.c1.y, s.c0.y), math.float4(0f, 0f, 1f, 1f));
+                v = math.mul(v, q);
+                qm = math.float3x3(q);
+                s = math.mul(math.mul(math.transpose(qm), s), qm);
+
+                q = approxGivensQuat(math.float3(s.c1.y, s.c2.z, s.c1.z), math.float4(1f, 0f, 0f, 1f));
+                v = math.mul(v, q);
+                qm = math.float3x3(q);
+                s = math.mul(math.mul(math.transpose(qm), s), qm);
+
+                q = approxGivensQuat(math.float3(s.c2.z, s.c0.x, s.c2.x), math.float4(0f, 1f, 0f, 1f));
+                v = math.mul(v, q);
+                qm = math.float3x3(q);
+                s = math.mul(math.mul(math.transpose(qm), s), qm);
+            }
+
+            return v;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static float3 singularValuesDecomposition(float3x3 a, out quaternion u, out quaternion v)
+        {
+            u = quaternion.identity;
+            v = quaternion.identity;
+
+            var s = math.mul(math.transpose(a), a);
+            v = jacobiIteration(ref s);
+            var b = math.float3x3(v);
+            b = math.mul(a, b);
+            sortSingularValues(ref b, ref v);
+            u = givensQRFactorization(b, out var e);
+
+            return math.float3(e.c0.x, e.c1.y, e.c2.z);
+        }
+
+        public const float k_EpsilonDeterminant = 1e-6f;
+        public const float k_EpsilonRCP = 1e-9f;
+        public const float k_EpsilonNormalSqrt = 1e-15f;
+        public const float k_EpsilonNormal = 1e-30f;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        static float3 rcpsafe(float3 x, float epsilon = k_EpsilonRCP) =>
+            math.select(math.rcp(x), float3.zero, math.abs(x) < epsilon);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static float3x3 svdInverse(float3x3 a)
+        {
+            var e = singularValuesDecomposition(a, out var u, out var v);
+            var um = math.float3x3(u);
+            var vm = math.float3x3(v);
+
+            return math.mul(vm, math.scaleMul(rcpsafe(e, k_EpsilonDeterminant), math.transpose(um)));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static quaternion svdRotation(float3x3 a)
+        {
+            singularValuesDecomposition(a, out var u, out var v);
+            return math.mul(u, math.conjugate(v));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Unity.Mathematics/svd.cs.meta b/src/Unity.Mathematics/svd.cs.meta
new file mode 100644
index 00000000..e7924355
--- /dev/null
+++ b/src/Unity.Mathematics/svd.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bc4f01dc4f3d8489f85ca8dff8563871
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

From 022330820f465c464adab388847bbefb1ba41468 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Wed, 26 Jan 2022 14:10:16 -0800
Subject: [PATCH 39/94] Fix warning for unused variable. (#211)

---
 src/Tests/Tests/Shared/TestMath.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Tests/Tests/Shared/TestMath.cs b/src/Tests/Tests/Shared/TestMath.cs
index 1c42283a..7691c5d3 100644
--- a/src/Tests/Tests/Shared/TestMath.cs
+++ b/src/Tests/Tests/Shared/TestMath.cs
@@ -4098,7 +4098,7 @@ public static void mulScale()
                 0.132552310824394226074f, 0.000265292444964870810509f, 0.233480587601661682129f,
                 0.0606870166957378387451f, 0.043273795396089553833f, 0.274842619895935058594f);
 
-            TestUtils.AreEqual(expected, actual, 1e-5);
+            TestUtils.AreEqual(expected, actual, tolerance);
         }
 
         [TestCompiler]

From 05978bd760282fe449b807423e4e735d7f323505 Mon Sep 17 00:00:00 2001
From: Olivier Dionne <olivierd@unity3d.com>
Date: Thu, 27 Jan 2022 19:15:39 -0500
Subject: [PATCH 40/94] updated changelog

---
 src/CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index 46c7a0e3..33ffdf40 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -11,6 +11,7 @@
 * Added `math.rotation` to extract a quaternion rotation from a float3x3 (that may have scale).
 * Added `math.mulScale` to scale columns of a float3x3 with scaling coefficients in a float3.
 * Added `math.scaleMul` to scale rows of a float3x3 with scaling coefficients in a float3.
+* Added `AffineTransform` type.
 ### Changed
 * `asfloat(uint)`, `asuint(float)`, `asint(float)` and other related methods are now faster in mono without Burst. Other methods which use these will see a performance improvement.
 * Modified `quaternion.nlerp` to be branchless.

From 1cc9d19a8e44edaa891102c61753bfbb316cdcf1 Mon Sep 17 00:00:00 2001
From: Olivier Dionne <olivierd@unity3d.com>
Date: Thu, 27 Jan 2022 19:25:43 -0500
Subject: [PATCH 41/94] Fix comment

---
 src/Unity.Mathematics/quaternion.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Unity.Mathematics/quaternion.cs b/src/Unity.Mathematics/quaternion.cs
index 465fe58a..b013fd24 100644
--- a/src/Unity.Mathematics/quaternion.cs
+++ b/src/Unity.Mathematics/quaternion.cs
@@ -710,6 +710,7 @@ public static float angle(quaternion q1, quaternion q2)
             return diff + diff;
         }
 
+        /// <summary>
         /// Extracts the rotation from a matrix.
         /// </summary>
         /// <remarks>This method supports any type of rotation matrix: if the matrix has a non uniform scale you should use this method.</remarks>

From 7b89c877dda5db1abf7d1f9d3d2842888228a383 Mon Sep 17 00:00:00 2001
From: Olivier Dionne <olivierd@unity3d.com>
Date: Thu, 27 Jan 2022 20:12:14 -0500
Subject: [PATCH 42/94] Adding more tests

---
 src/Tests/Tests/Shared/TestAffineTransform.cs | 104 +++++++++++++++++-
 1 file changed, 99 insertions(+), 5 deletions(-)

diff --git a/src/Tests/Tests/Shared/TestAffineTransform.cs b/src/Tests/Tests/Shared/TestAffineTransform.cs
index 0a2c9f5b..460650cd 100644
--- a/src/Tests/Tests/Shared/TestAffineTransform.cs
+++ b/src/Tests/Tests/Shared/TestAffineTransform.cs
@@ -7,12 +7,63 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     class TestAffineTransform
     {
+        [TestCompiler]
+        public static void affine_transform_construct_from_float3x3()
+        {
+            const float tolerance = 1e-6f;
+
+            float3x3 m3x3 = TestMatrix.test3x3_zyx;
+            AffineTransform tx = AffineTransform(m3x3);
+
+            float3x3 testM3x3 = float3x3(tx);
+
+            TestUtils.AreEqual(m3x3, testM3x3, tolerance);
+        }
+
+        [TestCompiler]
+        public static void affine_transform_construct_from_float3x4()
+        {
+            const float tolerance = 1e-6f;
+
+            float3x4 m3x4 = float3x4(TestMatrix.test3x3_zyx.c0, TestMatrix.test3x3_zyx.c1, TestMatrix.test3x3_zyx.c2, float3(1f, 2f, 3f));
+            AffineTransform tx = AffineTransform(m3x4);
+
+            float3x4 testM3x4 = float3x4(tx);
+
+            TestUtils.AreEqual(m3x4, testM3x4, tolerance);
+        }
+
+        [TestCompiler]
+        public static void affine_transform_construct_from_float4x4()
+        {
+            const float tolerance = 1e-6f;
+
+            float4x4 m4x4 = TestMatrix.test4x4_zyx;
+            AffineTransform tx = AffineTransform(m4x4);
+
+            float4x4 testM4x4 = float4x4(tx);
+
+            TestUtils.AreEqual(m4x4, testM4x4, tolerance);
+        }
+
+        [TestCompiler]
+        public static void affine_transform_construct_from_RigidTransform()
+        {
+            const float tolerance = 1e-6f;
+
+            RigidTransform r = RigidTransform(TestMatrix.test4x4_xyz);
+            AffineTransform tx = AffineTransform(r);
+
+            TestUtils.AreEqual(math.float3x3(r.rot), tx.rs, tolerance);
+            TestUtils.AreEqual(r.pos, tx.t, tolerance);
+        }
+
         [TestCompiler]
         public static void affine_transform_inverse()
         {
             const float tolerance = 1e-6f;
 
-            var tx = AffineTransform(float3(5, 6, 7), normalize(math.float4(1, 2, 3, 4)), float3(2, 3, 4));
+            var tx = AffineTransform(float3(5f, 6f, 7f), normalize(math.float4(1f, 2f, 3f, 4f)), float3(2f, 3f, 4f));
             var invTx = inverse(tx);
 
             TestUtils.AreEqual(float4x4.identity, mul(tx, invTx), tolerance);
@@ -23,7 +74,7 @@ public static void affine_transform_inverse_zero_rs_returns_zero()
         {
             const float tolerance = 1e-30f;
 
-            var tx = AffineTransform(float3(5, 6, 7), normalize(float4(1, 2, 3, 4)), float3.zero);
+            var tx = AffineTransform(float3(5f, 6f, 7f), normalize(float4(1f, 2f, 3f, 4f)), float3.zero);
             var invTx = inverse(tx);
 
             TestUtils.AreEqual(float3x4.zero, invTx, tolerance);
@@ -35,7 +86,7 @@ public static void affine_transform_inverse_pico_scale()
             // slightly larger tolerance (vs 1e-6f) for PS4
             const float tolerance = 2e-6f;
 
-            var tx = AffineTransform(float3(5, 6, 7), normalize(float4(1, 2, 3, 4)), float3(1e-12f, 1e-12f, 1e-12f));
+            var tx = AffineTransform(float3(5f, 6f, 7f), normalize(float4(1f, 2f, 3f, 4f)), float3(1e-12f, 1e-12f, 1e-12f));
             var invTx = inverse(tx);
 
             TestUtils.AreEqual(float4x4.identity, mul(tx, invTx), tolerance);
@@ -48,7 +99,7 @@ public static void affine_transform_inverse_singular()
             // since it uses the svd iterative solver
             const float tolerance = 1e-1f;
 
-            var tx = AffineTransform(float3(5, 6, 7), normalize(float4(1, 2, 3, 4)), float3(0, 3, 4));
+            var tx = AffineTransform(float3(5f, 6f, 7f), normalize(float4(1f, 2f, 3f, 4f)), float3(0f, 3f, 4f));
             var invTx = inverse(tx);
 
             // pseudo inverse penrose #1 test
@@ -61,12 +112,55 @@ public static void affine_transform_decompose()
         {
             const float tolerance = 1e-6f;
 
-            var tx = AffineTransform(float3(5, 6, 7), normalize(float4(1, 2, 3, 4)), float3(2, 3, 4));
+            var tx = AffineTransform(float3(5f, 6f, 7f), normalize(float4(1f, 2f, 3f, 4f)), float3(2f, 3f, 4f));
             decompose(tx, out var t, out var r, out var s);
 
             // Recompose matrix
             var testTx = AffineTransform(t, r, s);
             TestUtils.AreEqual(float4x4(tx), float4x4(testTx), tolerance);
         }
+
+        [TestCompiler]
+        public static void affine_transform_mul_vector()
+        {
+            float4x4 m = TestMatrix.test4x4_xyz;
+            AffineTransform tx = AffineTransform(m);
+
+            float3 vector = float3(1.1f, -2.2f, 3.5f);
+
+            float4 mvector0 = mul(m, float4(vector, 0f));
+            float4 txvector0 = mul(tx, float4(vector, 0f));
+            TestUtils.AreEqual(mvector0, txvector0, 0.0001f);
+
+            float4 mvector1 = mul(m, float4(vector, 1f));
+            float4 txvector1 = mul(tx, float4(vector, 1f));
+            TestUtils.AreEqual(mvector1, txvector1, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void affine_transform_rotate_vector()
+        {
+            float3x3 m = TestMatrix.test3x3_xyz;
+            AffineTransform tx = AffineTransform(m);
+
+            float3 vector = float3(1.1f, -2.2f, 3.5f);
+
+            float3 mvector0 = mul(m, vector);
+            float3 txvector0 = rotate(tx, vector);
+            TestUtils.AreEqual(mvector0, txvector0, 0.0001f);
+        }
+
+        [TestCompiler]
+        public static void affine_transform_transform_point()
+        {
+            float4x4 m = float4x4(TestMatrix.test3x3_zyx, float3(1f, 2f, 3f));
+            AffineTransform tx = AffineTransform(m);
+
+            float3 pt = float3(1.1f, -2.2f, 3.5f);
+
+            float3 mPt0 = transform(m, pt);
+            float3 txPt0 = transform(tx, pt);
+            TestUtils.AreEqual(mPt0, txPt0, 0.0001f);
+        }
     }
 }
\ No newline at end of file

From 84a8c6aad160980dd26846ed42faa72722769f36 Mon Sep 17 00:00:00 2001
From: Olivier Dionne <olivierd@unity3d.com>
Date: Fri, 28 Jan 2022 15:44:16 -0500
Subject: [PATCH 43/94] add missing csproj files

---
 src/Tests/Unity.Mathematics.Tests.csproj       | 1 +
 src/Unity.Mathematics/Unity.Mathematics.csproj | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/Tests/Unity.Mathematics.Tests.csproj b/src/Tests/Unity.Mathematics.Tests.csproj
index d6fe8748..89872c1c 100644
--- a/src/Tests/Unity.Mathematics.Tests.csproj
+++ b/src/Tests/Unity.Mathematics.Tests.csproj
@@ -50,6 +50,7 @@
   <ItemGroup>
     <Compile Include="TestCompilerAttribute.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Tests\Shared\TestAffineTransform.cs" />
     <Compile Include="Tests\Shared\TestBitmanipulation.cs" />
     <Compile Include="Tests\Shared\TestBool2.gen.cs" />
     <Compile Include="Tests\Shared\TestBool2x2.gen.cs" />
diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj
index da1856ac..906c6011 100644
--- a/src/Unity.Mathematics/Unity.Mathematics.csproj
+++ b/src/Unity.Mathematics/Unity.Mathematics.csproj
@@ -63,6 +63,7 @@
     <Reference Include="System" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="affine_transform.cs" />
     <Compile Include="bool2.gen.cs" />
     <Compile Include="bool2x2.gen.cs" />
     <Compile Include="bool2x3.gen.cs" />

From dfaeb8b7e1c1d73878edbdb677989a83a5ac7fa7 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Wed, 9 Feb 2022 15:08:01 -0800
Subject: [PATCH 44/94] More descriptive parameter names (#215)

* Add descriptive parameter names for lerp.

* Better names for unlerp.

* Descriptive names for mad() and remap().

* Descriptive names for clamp.

* Descriptive names for smoothstep.

* Descriptive names for select.

* Descriptive step.

* Descriptive refract.

* Descriptive project.

* Changelog update.
---
 src/CHANGELOG.md              |    1 +
 src/Unity.Mathematics/math.cs | 1318 ++++++++++++++++-----------------
 2 files changed, 660 insertions(+), 659 deletions(-)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index 33ffdf40..d744d474 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -15,6 +15,7 @@
 ### Changed
 * `asfloat(uint)`, `asuint(float)`, `asint(float)` and other related methods are now faster in mono without Burst. Other methods which use these will see a performance improvement.
 * Modified `quaternion.nlerp` to be branchless.
+* More descriptive parameter names for many methods in `math` class.
 ### Deprecated
 ### Removed
 ### Fixed
diff --git a/src/Unity.Mathematics/math.cs b/src/Unity.Mathematics/math.cs
index f2d1b285..73204610 100644
--- a/src/Unity.Mathematics/math.cs
+++ b/src/Unity.Mathematics/math.cs
@@ -1057,394 +1057,394 @@ public static bool4 ispow2(uint4 x)
         public static double4 max(double4 x, double4 y) { return new double4(max(x.x, y.x), max(x.y, y.y), max(x.z, y.z), max(x.w, y.w)); }
 
 
-        /// <summary>Returns the result of linearly interpolating from x to y using the interpolation parameter s.</summary>
+        /// <summary>Returns the result of linearly interpolating from start to end using the interpolation parameter t.</summary>
         /// <remarks>
         /// If the interpolation parameter is not in the range [0, 1], then this function extrapolates.
         /// </remarks>
-        /// <param name="x">The first endpoint, corresponding to the interpolation parameter value of 0.</param>
-        /// <param name="y">The second endpoint, corresponding to the interpolation parameter value of 1.</param>
-        /// <param name="s">The interpolation parameter. May be a value outside the interval [0, 1].</param>
-        /// <returns>The interpolation from x to y.</returns>
+        /// <param name="start">The start point, corresponding to the interpolation parameter value of 0.</param>
+        /// <param name="end">The end point, corresponding to the interpolation parameter value of 1.</param>
+        /// <param name="t">The interpolation parameter. May be a value outside the interval [0, 1].</param>
+        /// <returns>The interpolation from start to end.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float lerp(float x, float y, float s) { return x + s * (y - x); }
+        public static float lerp(float start, float end, float t) { return start + t * (end - start); }
 
-        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter s.</summary>
+        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter t.</summary>
         /// <remarks>
         /// If the interpolation parameter is not in the range [0, 1], then this function extrapolates.
         /// </remarks>
-        /// <param name="x">The first endpoint, corresponding to the interpolation parameter value of 0.</param>
-        /// <param name="y">The second endpoint, corresponding to the interpolation parameter value of 1.</param>
-        /// <param name="s">The interpolation parameter. May be a value outside the interval [0, 1].</param>
+        /// <param name="start">The start point, corresponding to the interpolation parameter value of 0.</param>
+        /// <param name="end">The end point, corresponding to the interpolation parameter value of 1.</param>
+        /// <param name="t">The interpolation parameter. May be a value outside the interval [0, 1].</param>
         /// <returns>The componentwise interpolation from x to y.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 lerp(float2 x, float2 y, float s) { return x + s * (y - x); }
+        public static float2 lerp(float2 start, float2 end, float t) { return start + t * (end - start); }
 
-        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter s.</summary>
+        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter t.</summary>
         /// <remarks>
         /// If the interpolation parameter is not in the range [0, 1], then this function extrapolates.
         /// </remarks>
-        /// <param name="x">The first endpoint, corresponding to the interpolation parameter value of 0.</param>
-        /// <param name="y">The second endpoint, corresponding to the interpolation parameter value of 1.</param>
-        /// <param name="s">The interpolation parameter. May be a value outside the interval [0, 1].</param>
+        /// <param name="start">The start point, corresponding to the interpolation parameter value of 0.</param>
+        /// <param name="end">The end point, corresponding to the interpolation parameter value of 1.</param>
+        /// <param name="t">The interpolation parameter. May be a value outside the interval [0, 1].</param>
         /// <returns>The componentwise interpolation from x to y.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 lerp(float3 x, float3 y, float s) { return x + s * (y - x); }
+        public static float3 lerp(float3 start, float3 end, float t) { return start + t * (end - start); }
 
-        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter s.</summary>
+        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter t.</summary>
         /// <remarks>
         /// If the interpolation parameter is not in the range [0, 1], then this function extrapolates.
         /// </remarks>
-        /// <param name="x">The first endpoint, corresponding to the interpolation parameter value of 0.</param>
-        /// <param name="y">The second endpoint, corresponding to the interpolation parameter value of 1.</param>
-        /// <param name="s">The interpolation parameter. May be a value outside the interval [0, 1].</param>
+        /// <param name="start">The start point, corresponding to the interpolation parameter value of 0.</param>
+        /// <param name="end">The end point, corresponding to the interpolation parameter value of 1.</param>
+        /// <param name="t">The interpolation parameter. May be a value outside the interval [0, 1].</param>
         /// <returns>The componentwise interpolation from x to y.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 lerp(float4 x, float4 y, float s) { return x + s * (y - x); }
+        public static float4 lerp(float4 start, float4 end, float t) { return start + t * (end - start); }
 
 
-        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter s.</summary>
+        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter t.</summary>
         /// <remarks>
         /// If the interpolation parameter is not in the range [0, 1], then this function extrapolates.
         /// </remarks>
-        /// <param name="x">The first endpoint, corresponding to the interpolation parameter value of 0.</param>
-        /// <param name="y">The second endpoint, corresponding to the interpolation parameter value of 1.</param>
-        /// <param name="s">The interpolation parameter. May be a value outside the interval [0, 1].</param>
+        /// <param name="start">The start point, corresponding to the interpolation parameter value of 0.</param>
+        /// <param name="end">The end point, corresponding to the interpolation parameter value of 1.</param>
+        /// <param name="t">The interpolation parameter. May be a value outside the interval [0, 1].</param>
         /// <returns>The componentwise interpolation from x to y.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 lerp(float2 x, float2 y, float2 s) { return x + s * (y - x); }
+        public static float2 lerp(float2 start, float2 end, float2 t) { return start + t * (end - start); }
 
-        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter s.</summary>
+        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter t.</summary>
         /// <remarks>
         /// If the interpolation parameter is not in the range [0, 1], then this function extrapolates.
         /// </remarks>
-        /// <param name="x">The first endpoint, corresponding to the interpolation parameter value of 0.</param>
-        /// <param name="y">The second endpoint, corresponding to the interpolation parameter value of 1.</param>
-        /// <param name="s">The interpolation parameter. May be a value outside the interval [0, 1].</param>
+        /// <param name="start">The start point, corresponding to the interpolation parameter value of 0.</param>
+        /// <param name="end">The end point, corresponding to the interpolation parameter value of 1.</param>
+        /// <param name="t">The interpolation parameter. May be a value outside the interval [0, 1].</param>
         /// <returns>The componentwise interpolation from x to y.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 lerp(float3 x, float3 y, float3 s) { return x + s * (y - x); }
+        public static float3 lerp(float3 start, float3 end, float3 t) { return start + t * (end - start); }
 
-        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter s.</summary>
+        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter t.</summary>
         /// <remarks>
         /// If the interpolation parameter is not in the range [0, 1], then this function extrapolates.
         /// </remarks>
-        /// <param name="x">The first endpoint, corresponding to the interpolation parameter value of 0.</param>
-        /// <param name="y">The second endpoint, corresponding to the interpolation parameter value of 1.</param>
-        /// <param name="s">The interpolation parameter. May be a value outside the interval [0, 1].</param>
+        /// <param name="start">The start point, corresponding to the interpolation parameter value of 0.</param>
+        /// <param name="end">The end point, corresponding to the interpolation parameter value of 1.</param>
+        /// <param name="t">The interpolation parameter. May be a value outside the interval [0, 1].</param>
         /// <returns>The componentwise interpolation from x to y.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 lerp(float4 x, float4 y, float4 s) { return x + s * (y - x); }
+        public static float4 lerp(float4 start, float4 end, float4 t) { return start + t * (end - start); }
 
 
-        /// <summary>Returns the result of linearly interpolating from x to y using the interpolation parameter s.</summary>
+        /// <summary>Returns the result of linearly interpolating from x to y using the interpolation parameter t.</summary>
         /// <remarks>
         /// If the interpolation parameter is not in the range [0, 1], then this function extrapolates.
         /// </remarks>
-        /// <param name="x">The first endpoint, corresponding to the interpolation parameter value of 0.</param>
-        /// <param name="y">The second endpoint, corresponding to the interpolation parameter value of 1.</param>
-        /// <param name="s">The interpolation parameter. May be a value outside the interval [0, 1].</param>
+        /// <param name="start">The start point, corresponding to the interpolation parameter value of 0.</param>
+        /// <param name="end">The end point, corresponding to the interpolation parameter value of 1.</param>
+        /// <param name="t">The interpolation parameter. May be a value outside the interval [0, 1].</param>
         /// <returns>The interpolation from x to y.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double lerp(double x, double y, double s) { return x + s * (y - x); }
+        public static double lerp(double start, double end, double t) { return start + t * (end - start); }
 
-        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter s.</summary>
+        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter t.</summary>
         /// <remarks>
         /// If the interpolation parameter is not in the range [0, 1], then this function extrapolates.
         /// </remarks>
-        /// <param name="x">The first endpoint, corresponding to the interpolation parameter value of 0.</param>
-        /// <param name="y">The second endpoint, corresponding to the interpolation parameter value of 1.</param>
-        /// <param name="s">The interpolation parameter. May be a value outside the interval [0, 1].</param>
+        /// <param name="start">The start point, corresponding to the interpolation parameter value of 0.</param>
+        /// <param name="end">The end point, corresponding to the interpolation parameter value of 1.</param>
+        /// <param name="t">The interpolation parameter. May be a value outside the interval [0, 1].</param>
         /// <returns>The componentwise interpolation from x to y.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double2 lerp(double2 x, double2 y, double s) { return x + s * (y - x); }
+        public static double2 lerp(double2 start, double2 end, double t) { return start + t * (end - start); }
 
-        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter s.</summary>
+        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter t.</summary>
         /// <remarks>
         /// If the interpolation parameter is not in the range [0, 1], then this function extrapolates.
         /// </remarks>
-        /// <param name="x">The first endpoint, corresponding to the interpolation parameter value of 0.</param>
-        /// <param name="y">The second endpoint, corresponding to the interpolation parameter value of 1.</param>
-        /// <param name="s">The interpolation parameter. May be a value outside the interval [0, 1].</param>
+        /// <param name="start">The start point, corresponding to the interpolation parameter value of 0.</param>
+        /// <param name="end">The end point, corresponding to the interpolation parameter value of 1.</param>
+        /// <param name="t">The interpolation parameter. May be a value outside the interval [0, 1].</param>
         /// <returns>The componentwise interpolation from x to y.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double3 lerp(double3 x, double3 y, double s) { return x + s * (y - x); }
+        public static double3 lerp(double3 start, double3 end, double t) { return start + t * (end - start); }
 
-        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter s.</summary>
+        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the interpolation parameter t.</summary>
         /// <remarks>
         /// If the interpolation parameter is not in the range [0, 1], then this function extrapolates.
         /// </remarks>
-        /// <param name="x">The first endpoint, corresponding to the interpolation parameter value of 0.</param>
-        /// <param name="y">The second endpoint, corresponding to the interpolation parameter value of 1.</param>
-        /// <param name="s">The interpolation parameter. May be a value outside the interval [0, 1].</param>
+        /// <param name="start">The start point, corresponding to the interpolation parameter value of 0.</param>
+        /// <param name="end">The end point, corresponding to the interpolation parameter value of 1.</param>
+        /// <param name="t">The interpolation parameter. May be a value outside the interval [0, 1].</param>
         /// <returns>The componentwise interpolation from x to y.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double4 lerp(double4 x, double4 y, double s) { return x + s * (y - x); }
+        public static double4 lerp(double4 start, double4 end, double t) { return start + t * (end - start); }
 
 
-        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter s.</summary>
+        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter t.</summary>
         /// <remarks>
         /// If the interpolation parameter is not in the range [0, 1], then this function extrapolates.
         /// </remarks>
-        /// <param name="x">The first endpoint, corresponding to the interpolation parameter value of 0.</param>
-        /// <param name="y">The second endpoint, corresponding to the interpolation parameter value of 1.</param>
-        /// <param name="s">The interpolation parameter. May be a value outside the interval [0, 1].</param>
+        /// <param name="start">The start point, corresponding to the interpolation parameter value of 0.</param>
+        /// <param name="end">The end point, corresponding to the interpolation parameter value of 1.</param>
+        /// <param name="t">The interpolation parameter. May be a value outside the interval [0, 1].</param>
         /// <returns>The componentwise interpolation from x to y.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double2 lerp(double2 x, double2 y, double2 s) { return x + s * (y - x); }
+        public static double2 lerp(double2 start, double2 end, double2 t) { return start + t * (end - start); }
 
-        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter s.</summary>
+        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter t.</summary>
         /// <remarks>
         /// If the interpolation parameter is not in the range [0, 1], then this function extrapolates.
         /// </remarks>
-        /// <param name="x">The first endpoint, corresponding to the interpolation parameter value of 0.</param>
-        /// <param name="y">The second endpoint, corresponding to the interpolation parameter value of 1.</param>
-        /// <param name="s">The interpolation parameter. May be a value outside the interval [0, 1].</param>
+        /// <param name="start">The start point, corresponding to the interpolation parameter value of 0.</param>
+        /// <param name="end">The end point, corresponding to the interpolation parameter value of 1.</param>
+        /// <param name="t">The interpolation parameter. May be a value outside the interval [0, 1].</param>
         /// <returns>The componentwise interpolation from x to y.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double3 lerp(double3 x, double3 y, double3 s) { return x + s * (y - x); }
+        public static double3 lerp(double3 start, double3 end, double3 t) { return start + t * (end - start); }
 
-        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter s.</summary>
+        /// <summary>Returns the result of a componentwise linear interpolating from x to y using the corresponding components of the interpolation parameter t.</summary>
         /// <remarks>
         /// If the interpolation parameter is not in the range [0, 1], then this function extrapolates.
         /// </remarks>
-        /// <param name="x">The first endpoint, corresponding to the interpolation parameter value of 0.</param>
-        /// <param name="y">The second endpoint, corresponding to the interpolation parameter value of 1.</param>
-        /// <param name="s">The interpolation parameter. May be a value outside the interval [0, 1].</param>
+        /// <param name="start">The start point, corresponding to the interpolation parameter value of 0.</param>
+        /// <param name="end">The end point, corresponding to the interpolation parameter value of 1.</param>
+        /// <param name="t">The interpolation parameter. May be a value outside the interval [0, 1].</param>
         /// <returns>The componentwise interpolation from x to y.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double4 lerp(double4 x, double4 y, double4 s) { return x + s * (y - x); }
+        public static double4 lerp(double4 start, double4 end, double4 t) { return start + t * (end - start); }
 
 
         /// <summary>Returns the result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a).</summary>
-        /// <param name="a">The first endpoint of the range.</param>
-        /// <param name="b">The second endpoint of the range.</param>
+        /// <param name="start">The start point of the range.</param>
+        /// <param name="end">The end point of the range.</param>
         /// <param name="x">The value to normalize to the range.</param>
         /// <returns>The interpolation parameter of x with respect to the input range [a, b].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float unlerp(float a, float b, float x) { return (x - a) / (b - a); }
+        public static float unlerp(float start, float end, float x) { return (x - start) / (end - start); }
 
         /// <summary>Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a).</summary>
-        /// <param name="a">The first endpoint of the range.</param>
-        /// <param name="b">The second endpoint of the range.</param>
+        /// <param name="start">The start point of the range.</param>
+        /// <param name="end">The end point of the range.</param>
         /// <param name="x">The value to normalize to the range.</param>
         /// <returns>The componentwise interpolation parameter of x with respect to the input range [a, b].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 unlerp(float2 a, float2 b, float2 x) { return (x - a) / (b - a); }
+        public static float2 unlerp(float2 start, float2 end, float2 x) { return (x - start) / (end - start); }
 
         /// <summary>Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a).</summary>
-        /// <param name="a">The first endpoint of the range.</param>
-        /// <param name="b">The second endpoint of the range.</param>
+        /// <param name="start">The start point of the range.</param>
+        /// <param name="end">The end point of the range.</param>
         /// <param name="x">The value to normalize to the range.</param>
         /// <returns>The componentwise interpolation parameter of x with respect to the input range [a, b].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 unlerp(float3 a, float3 b, float3 x) { return (x - a) / (b - a); }
+        public static float3 unlerp(float3 start, float3 end, float3 x) { return (x - start) / (end - start); }
 
         /// <summary>Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a).</summary>
-        /// <param name="a">The first endpoint of the range.</param>
-        /// <param name="b">The second endpoint of the range.</param>
+        /// <param name="start">The start point of the range.</param>
+        /// <param name="end">The end point of the range.</param>
         /// <param name="x">The value to normalize to the range.</param>
         /// <returns>The componentwise interpolation parameter of x with respect to the input range [a, b].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 unlerp(float4 a, float4 b, float4 x) { return (x - a) / (b - a); }
+        public static float4 unlerp(float4 start, float4 end, float4 x) { return (x - start) / (end - start); }
 
 
         /// <summary>Returns the result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a).</summary>
-        /// <param name="a">The first endpoint of the range.</param>
-        /// <param name="b">The second endpoint of the range.</param>
+        /// <param name="start">The start point of the range.</param>
+        /// <param name="end">The end point of the range.</param>
         /// <param name="x">The value to normalize to the range.</param>
         /// <returns>The interpolation parameter of x with respect to the input range [a, b].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double unlerp(double a, double b, double x) { return (x - a) / (b - a); }
+        public static double unlerp(double start, double end, double x) { return (x - start) / (end - start); }
 
         /// <summary>Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a).</summary>
-        /// <param name="a">The first endpoint of the range.</param>
-        /// <param name="b">The second endpoint of the range.</param>
+        /// <param name="start">The start point of the range.</param>
+        /// <param name="end">The end point of the range.</param>
         /// <param name="x">The value to normalize to the range.</param>
         /// <returns>The componentwise interpolation parameter of x with respect to the input range [a, b].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double2 unlerp(double2 a, double2 b, double2 x) { return (x - a) / (b - a); }
+        public static double2 unlerp(double2 start, double2 end, double2 x) { return (x - start) / (end - start); }
 
         /// <summary>Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a).</summary>
-        /// <param name="a">The first endpoint of the range.</param>
-        /// <param name="b">The second endpoint of the range.</param>
+        /// <param name="start">The start point of the range.</param>
+        /// <param name="end">The end point of the range.</param>
         /// <param name="x">The value to normalize to the range.</param>
         /// <returns>The componentwise interpolation parameter of x with respect to the input range [a, b].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double3 unlerp(double3 a, double3 b, double3 x) { return (x - a) / (b - a); }
+        public static double3 unlerp(double3 start, double3 end, double3 x) { return (x - start) / (end - start); }
 
         /// <summary>Returns the componentwise result of normalizing a floating point value x to a range [a, b]. The opposite of lerp. Equivalent to (x - a) / (b - a).</summary>
-        /// <param name="a">The first endpoint of the range.</param>
-        /// <param name="b">The second endpoint of the range.</param>
+        /// <param name="start">The start point of the range.</param>
+        /// <param name="end">The end point of the range.</param>
         /// <param name="x">The value to normalize to the range.</param>
         /// <returns>The componentwise interpolation parameter of x with respect to the input range [a, b].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double4 unlerp(double4 a, double4 b, double4 x) { return (x - a) / (b - a); }
+        public static double4 unlerp(double4 start, double4 end, double4 x) { return (x - start) / (end - start); }
 
 
-        /// <summary>Returns the result of a non-clamping linear remapping of a value x from source range [a, b] to the destination range [c, d].</summary>
-        /// <param name="a">The first endpoint of the source range [a,b].</param>
-        /// <param name="b">The second endpoint of the source range [a, b].</param>
-        /// <param name="c">The first endpoint of the destination range [c, d].</param>
-        /// <param name="d">The second endpoint of the destination range [c, d].</param>
+        /// <summary>Returns the result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd].</summary>
+        /// <param name="srcStart">The start point of the source range [srcStart, srcEnd].</param>
+        /// <param name="srcEnd">The end point of the source range [srcStart, srcEnd].</param>
+        /// <param name="dstStart">The start point of the destination range [dstStart, dstEnd].</param>
+        /// <param name="dstEnd">The end point of the destination range [dstStart, dstEnd].</param>
         /// <param name="x">The value to remap from the source to destination range.</param>
         /// <returns>The remap of input x from the source range to the destination range.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float remap(float a, float b, float c, float d, float x) { return lerp(c, d, unlerp(a, b, x)); }
+        public static float remap(float srcStart, float srcEnd, float dstStart, float dstEnd, float x) { return lerp(dstStart, dstEnd, unlerp(srcStart, srcEnd, x)); }
 
-        /// <summary>Returns the componentwise result of a non-clamping linear remapping of a value x from source range [a, b] to the destination range [c, d].</summary>
-        /// <param name="a">The first endpoint of the source range [a,b].</param>
-        /// <param name="b">The second endpoint of the source range [a, b].</param>
-        /// <param name="c">The first endpoint of the destination range [c, d].</param>
-        /// <param name="d">The second endpoint of the destination range [c, d].</param>
+        /// <summary>Returns the componentwise result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd].</summary>
+        /// <param name="srcStart">The start point of the source range [srcStart, srcEnd].</param>
+        /// <param name="srcEnd">The end point of the source range [srcStart, srcEnd].</param>
+        /// <param name="dstStart">The start point of the destination range [dstStart, dstEnd].</param>
+        /// <param name="dstEnd">The end point of the destination range [dstStart, dstEnd].</param>
         /// <param name="x">The value to remap from the source to destination range.</param>
         /// <returns>The componentwise remap of input x from the source range to the destination range.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 remap(float2 a, float2 b, float2 c, float2 d, float2 x) { return lerp(c, d, unlerp(a, b, x)); }
+        public static float2 remap(float2 srcStart, float2 srcEnd, float2 dstStart, float2 dstEnd, float2 x) { return lerp(dstStart, dstEnd, unlerp(srcStart, srcEnd, x)); }
 
-        /// <summary>Returns the componentwise result of a non-clamping linear remapping of a value x from source range [a, b] to the destination range [c, d].</summary>
-        /// <param name="a">The first endpoint of the source range [a,b].</param>
-        /// <param name="b">The second endpoint of the source range [a, b].</param>
-        /// <param name="c">The first endpoint of the destination range [c, d].</param>
-        /// <param name="d">The second endpoint of the destination range [c, d].</param>
+        /// <summary>Returns the componentwise result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd].</summary>
+        /// <param name="srcStart">The start point of the source range [srcStart, srcEnd].</param>
+        /// <param name="srcEnd">The end point of the source range [srcStart, srcEnd].</param>
+        /// <param name="dstStart">The start point of the destination range [dstStart, dstEnd].</param>
+        /// <param name="dstEnd">The end point of the destination range [dstStart, dstEnd].</param>
         /// <param name="x">The value to remap from the source to destination range.</param>
         /// <returns>The componentwise remap of input x from the source range to the destination range.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 remap(float3 a, float3 b, float3 c, float3 d, float3 x) { return lerp(c, d, unlerp(a, b, x)); }
+        public static float3 remap(float3 srcStart, float3 srcEnd, float3 dstStart, float3 dstEnd, float3 x) { return lerp(dstStart, dstEnd, unlerp(srcStart, srcEnd, x)); }
 
-        /// <summary>Returns the componentwise result of a non-clamping linear remapping of a value x from source range [a, b] to the destination range [c, d].</summary>
-        /// <param name="a">The first endpoint of the source range [a,b].</param>
-        /// <param name="b">The second endpoint of the source range [a, b].</param>
-        /// <param name="c">The first endpoint of the destination range [c, d].</param>
-        /// <param name="d">The second endpoint of the destination range [c, d].</param>
+        /// <summary>Returns the componentwise result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd].</summary>
+        /// <param name="srcStart">The start point of the source range [srcStart, srcEnd].</param>
+        /// <param name="srcEnd">The end point of the source range [srcStart, srcEnd].</param>
+        /// <param name="dstStart">The start point of the destination range [dstStart, dstEnd].</param>
+        /// <param name="dstEnd">The end point of the destination range [dstStart, dstEnd].</param>
         /// <param name="x">The value to remap from the source to destination range.</param>
         /// <returns>The componentwise remap of input x from the source range to the destination range.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 remap(float4 a, float4 b, float4 c, float4 d, float4 x) { return lerp(c, d, unlerp(a, b, x)); }
+        public static float4 remap(float4 srcStart, float4 srcEnd, float4 dstStart, float4 dstEnd, float4 x) { return lerp(dstStart, dstEnd, unlerp(srcStart, srcEnd, x)); }
 
 
-        /// <summary>Returns the result of a non-clamping linear remapping of a value x from source range [a, b] to the destination range [c, d].</summary>
-        /// <param name="a">The first endpoint of the source range [a,b].</param>
-        /// <param name="b">The second endpoint of the source range [a, b].</param>
-        /// <param name="c">The first endpoint of the destination range [c, d].</param>
-        /// <param name="d">The second endpoint of the destination range [c, d].</param>
+        /// <summary>Returns the result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd].</summary>
+        /// <param name="srcStart">The start point of the source range [srcStart, srcEnd].</param>
+        /// <param name="srcEnd">The end point of the source range [srcStart, srcEnd].</param>
+        /// <param name="dstStart">The start point of the destination range [dstStart, dstEnd].</param>
+        /// <param name="dstEnd">The end point of the destination range [dstStart, dstEnd].</param>
         /// <param name="x">The value to remap from the source to destination range.</param>
         /// <returns>The remap of input x from the source range to the destination range.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double remap(double a, double b, double c, double d, double x) { return lerp(c, d, unlerp(a, b, x)); }
+        public static double remap(double srcStart, double srcEnd, double dstStart, double dstEnd, double x) { return lerp(dstStart, dstEnd, unlerp(srcStart, srcEnd, x)); }
 
-        /// <summary>Returns the componentwise result of a non-clamping linear remapping of a value x from source range [a, b] to the destination range [c, d].</summary>
-        /// <param name="a">The first endpoint of the source range [a,b].</param>
-        /// <param name="b">The second endpoint of the source range [a, b].</param>
-        /// <param name="c">The first endpoint of the destination range [c, d].</param>
-        /// <param name="d">The second endpoint of the destination range [c, d].</param>
+        /// <summary>Returns the componentwise result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd].</summary>
+        /// <param name="srcStart">The start point of the source range [srcStart, srcEnd].</param>
+        /// <param name="srcEnd">The end point of the source range [srcStart, srcEnd].</param>
+        /// <param name="dstStart">The start point of the destination range [dstStart, dstEnd].</param>
+        /// <param name="dstEnd">The end point of the destination range [dstStart, dstEnd].</param>
         /// <param name="x">The value to remap from the source to destination range.</param>
         /// <returns>The componentwise remap of input x from the source range to the destination range.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double2 remap(double2 a, double2 b, double2 c, double2 d, double2 x) { return lerp(c, d, unlerp(a, b, x)); }
+        public static double2 remap(double2 srcStart, double2 srcEnd, double2 dstStart, double2 dstEnd, double2 x) { return lerp(dstStart, dstEnd, unlerp(srcStart, srcEnd, x)); }
 
-        /// <summary>Returns the componentwise result of a non-clamping linear remapping of a value x from source range [a, b] to the destination range [c, d].</summary>
-        /// <param name="a">The first endpoint of the source range [a,b].</param>
-        /// <param name="b">The second endpoint of the source range [a, b].</param>
-        /// <param name="c">The first endpoint of the destination range [c, d].</param>
-        /// <param name="d">The second endpoint of the destination range [c, d].</param>
+        /// <summary>Returns the componentwise result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd].</summary>
+        /// <param name="srcStart">The start point of the source range [srcStart, srcEnd].</param>
+        /// <param name="srcEnd">The end point of the source range [srcStart, srcEnd].</param>
+        /// <param name="dstStart">The start point of the destination range [dstStart, dstEnd].</param>
+        /// <param name="dstEnd">The end point of the destination range [dstStart, dstEnd].</param>
         /// <param name="x">The value to remap from the source to destination range.</param>
         /// <returns>The componentwise remap of input x from the source range to the destination range.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double3 remap(double3 a, double3 b, double3 c, double3 d, double3 x) { return lerp(c, d, unlerp(a, b, x)); }
+        public static double3 remap(double3 srcStart, double3 srcEnd, double3 dstStart, double3 dstEnd, double3 x) { return lerp(dstStart, dstEnd, unlerp(srcStart, srcEnd, x)); }
 
-        /// <summary>Returns the componentwise result of a non-clamping linear remapping of a value x from source range [a, b] to the destination range [c, d].</summary>
-        /// <param name="a">The first endpoint of the source range [a,b].</param>
-        /// <param name="b">The second endpoint of the source range [a, b].</param>
-        /// <param name="c">The first endpoint of the destination range [c, d].</param>
-        /// <param name="d">The second endpoint of the destination range [c, d].</param>
+        /// <summary>Returns the componentwise result of a non-clamping linear remapping of a value x from source range [srcStart, srcEnd] to the destination range [dstStart, dstEnd].</summary>
+        /// <param name="srcStart">The start point of the source range [srcStart, srcEnd].</param>
+        /// <param name="srcEnd">The end point of the source range [srcStart, srcEnd].</param>
+        /// <param name="dstStart">The start point of the destination range [dstStart, dstEnd].</param>
+        /// <param name="dstEnd">The end point of the destination range [dstStart, dstEnd].</param>
         /// <param name="x">The value to remap from the source to destination range.</param>
         /// <returns>The componentwise remap of input x from the source range to the destination range.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double4 remap(double4 a, double4 b, double4 c, double4 d, double4 x) { return lerp(c, d, unlerp(a, b, x)); }
+        public static double4 remap(double4 srcStart, double4 srcEnd, double4 dstStart, double4 dstEnd, double4 x) { return lerp(dstStart, dstEnd, unlerp(srcStart, srcEnd, x)); }
 
 
         /// <summary>Returns the result of a multiply-add operation (a * b + c) on 3 int values.</summary>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int mad(int a, int b, int c) { return a * b + c; }
+        public static int mad(int mulA, int mulB, int addC) { return mulA * mulB + addC; }
 
         /// <summary>Returns the result of a componentwise multiply-add operation (a * b + c) on 3 int2 vectors.</summary>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The componentwise multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int2 mad(int2 a, int2 b, int2 c) { return a * b + c; }
+        public static int2 mad(int2 mulA, int2 mulB, int2 addC) { return mulA * mulB + addC; }
 
         /// <summary>Returns the result of a componentwise multiply-add operation (a * b + c) on 3 int3 vectors.</summary>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The componentwise multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int3 mad(int3 a, int3 b, int3 c) { return a * b + c; }
+        public static int3 mad(int3 mulA, int3 mulB, int3 addC) { return mulA * mulB + addC; }
 
         /// <summary>Returns the result of a componentwise multiply-add operation (a * b + c) on 3 int4 vectors.</summary>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The componentwise multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int4 mad(int4 a, int4 b, int4 c) { return a * b + c; }
+        public static int4 mad(int4 mulA, int4 mulB, int4 addC) { return mulA * mulB + addC; }
 
 
         /// <summary>Returns the result of a multiply-add operation (a * b + c) on 3 uint values.</summary>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint mad(uint a, uint b, uint c) { return a * b + c; }
+        public static uint mad(uint mulA, uint mulB, uint addC) { return mulA * mulB + addC; }
 
         /// <summary>Returns the result of a componentwise multiply-add operation (a * b + c) on 3 uint2 vectors.</summary>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The componentwise multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint2 mad(uint2 a, uint2 b, uint2 c) { return a * b + c; }
+        public static uint2 mad(uint2 mulA, uint2 mulB, uint2 addC) { return mulA * mulB + addC; }
 
         /// <summary>Returns the result of a componentwise multiply-add operation (a * b + c) on 3 uint3 vectors.</summary>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The componentwise multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint3 mad(uint3 a, uint3 b, uint3 c) { return a * b + c; }
+        public static uint3 mad(uint3 mulA, uint3 mulB, uint3 addC) { return mulA * mulB + addC; }
 
         /// <summary>Returns the result of a componentwise multiply-add operation (a * b + c) on 3 uint4 vectors.</summary>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The componentwise multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint4 mad(uint4 a, uint4 b, uint4 c) { return a * b + c; }
+        public static uint4 mad(uint4 mulA, uint4 mulB, uint4 addC) { return mulA * mulB + addC; }
 
 
         /// <summary>Returns the result of a multiply-add operation (a * b + c) on 3 long values.</summary>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long mad(long a, long b, long c) { return a * b + c; }
+        public static long mad(long mulA, long mulB, long addC) { return mulA * mulB + addC; }
 
 
         /// <summary>Returns the result of a multiply-add operation (a * b + c) on 3 ulong values.</summary>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ulong mad(ulong a, ulong b, ulong c) { return a * b + c; }
+        public static ulong mad(ulong mulA, ulong mulB, ulong addC) { return mulA * mulB + addC; }
 
 
         /// <summary>Returns the result of a multiply-add operation (a * b + c) on 3 float values.</summary>
@@ -1453,12 +1453,12 @@ public static bool4 ispow2(uint4 x)
         /// FMA is more accurate due to rounding once at the end of the computation rather than twice that is required when
         /// this computation is not fused.
         /// </remarks>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float mad(float a, float b, float c) { return a * b + c; }
+        public static float mad(float mulA, float mulB, float addC) { return mulA * mulB + addC; }
 
         /// <summary>Returns the result of a componentwise multiply-add operation (a * b + c) on 3 float2 vectors.</summary>
         /// <remarks>
@@ -1466,12 +1466,12 @@ public static bool4 ispow2(uint4 x)
         /// FMA is more accurate due to rounding once at the end of the computation rather than twice that is required when
         /// this computation is not fused.
         /// </remarks>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The componentwise multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 mad(float2 a, float2 b, float2 c) { return a * b + c; }
+        public static float2 mad(float2 mulA, float2 mulB, float2 addC) { return mulA * mulB + addC; }
 
         /// <summary>Returns the result of a componentwise multiply-add operation (a * b + c) on 3 float3 vectors.</summary>
         /// <remarks>
@@ -1479,12 +1479,12 @@ public static bool4 ispow2(uint4 x)
         /// FMA is more accurate due to rounding once at the end of the computation rather than twice that is required when
         /// this computation is not fused.
         /// </remarks>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The componentwise multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 mad(float3 a, float3 b, float3 c) { return a * b + c; }
+        public static float3 mad(float3 mulA, float3 mulB, float3 addC) { return mulA * mulB + addC; }
 
         /// <summary>Returns the result of a componentwise multiply-add operation (a * b + c) on 3 float4 vectors.</summary>
         /// <remarks>
@@ -1492,12 +1492,12 @@ public static bool4 ispow2(uint4 x)
         /// FMA is more accurate due to rounding once at the end of the computation rather than twice that is required when
         /// this computation is not fused.
         /// </remarks>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The componentwise multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 mad(float4 a, float4 b, float4 c) { return a * b + c; }
+        public static float4 mad(float4 mulA, float4 mulB, float4 addC) { return mulA * mulB + addC; }
 
 
         /// <summary>Returns the result of a multiply-add operation (a * b + c) on 3 double values.</summary>
@@ -1506,12 +1506,12 @@ public static bool4 ispow2(uint4 x)
         /// FMA is more accurate due to rounding once at the end of the computation rather than twice that is required when
         /// this computation is not fused.
         /// </remarks>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double mad(double a, double b, double c) { return a * b + c; }
+        public static double mad(double mulA, double mulB, double addC) { return mulA * mulB + addC; }
 
         /// <summary>Returns the result of a componentwise multiply-add operation (a * b + c) on 3 double2 vectors.</summary>
         /// <remarks>
@@ -1519,12 +1519,12 @@ public static bool4 ispow2(uint4 x)
         /// FMA is more accurate due to rounding once at the end of the computation rather than twice that is required when
         /// this computation is not fused.
         /// </remarks>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The componentwise multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double2 mad(double2 a, double2 b, double2 c) { return a * b + c; }
+        public static double2 mad(double2 mulA, double2 mulB, double2 addC) { return mulA * mulB + addC; }
 
         /// <summary>Returns the result of a componentwise multiply-add operation (a * b + c) on 3 double3 vectors.</summary>
         /// <remarks>
@@ -1532,12 +1532,12 @@ public static bool4 ispow2(uint4 x)
         /// FMA is more accurate due to rounding once at the end of the computation rather than twice that is required when
         /// this computation is not fused.
         /// </remarks>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The componentwise multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double3 mad(double3 a, double3 b, double3 c) { return a * b + c; }
+        public static double3 mad(double3 mulA, double3 mulB, double3 addC) { return mulA * mulB + addC; }
 
         /// <summary>Returns the result of a componentwise multiply-add operation (a * b + c) on 3 double4 vectors.</summary>
         /// <remarks>
@@ -1545,161 +1545,161 @@ public static bool4 ispow2(uint4 x)
         /// FMA is more accurate due to rounding once at the end of the computation rather than twice that is required when
         /// this computation is not fused.
         /// </remarks>
-        /// <param name="a">First value to multiply.</param>
-        /// <param name="b">Second value to multiply.</param>
-        /// <param name="c">Third value to add to the product of a and b.</param>
+        /// <param name="mulA">First value to multiply.</param>
+        /// <param name="mulB">Second value to multiply.</param>
+        /// <param name="addC">Third value to add to the product of a and b.</param>
         /// <returns>The componentwise multiply-add of the inputs.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double4 mad(double4 a, double4 b, double4 c) { return a * b + c; }
+        public static double4 mad(double4 mulA, double4 mulB, double4 addC) { return mulA * mulB + addC; }
 
 
-        /// <summary>Returns the result of clamping the value x into the interval [a, b], where x, a and b are int values.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The clamping of the input x into the interval [a, b].</returns>
+        /// <summary>Returns the result of clamping the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are int values.</summary>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int clamp(int x, int a, int b) { return max(a, min(b, x)); }
+        public static int clamp(int valueToClamp, int lowerBound, int upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
         /// <summary>Returns the result of a componentwise clamping of the int2 x into the interval [a, b], where a and b are int2 vectors.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The componentwise clamping of the input x into the interval [a, b].</returns>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The componentwise clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int2 clamp(int2 x, int2 a, int2 b) { return max(a, min(b, x)); }
+        public static int2 clamp(int2 valueToClamp, int2 lowerBound, int2 upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
         /// <summary>Returns the result of a componentwise clamping of the int3 x into the interval [a, b], where x, a and b are int3 vectors.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The componentwise clamping of the input x into the interval [a, b].</returns>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The componentwise clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int3 clamp(int3 x, int3 a, int3 b) { return max(a, min(b, x)); }
+        public static int3 clamp(int3 valueToClamp, int3 lowerBound, int3 upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
-        /// <summary>Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are int4 vectors.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The componentwise clamping of the input x into the interval [a, b].</returns>
+        /// <summary>Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are int4 vectors.</summary>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The componentwise clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int4 clamp(int4 x, int4 a, int4 b) { return max(a, min(b, x)); }
+        public static int4 clamp(int4 valueToClamp, int4 lowerBound, int4 upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
 
-        /// <summary>Returns the result of clamping the value x into the interval [a, b], where x, a and b are uint values.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The clamping of the input x into the interval [a, b].</returns>
+        /// <summary>Returns the result of clamping the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are uint values.</summary>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint clamp(uint x, uint a, uint b) { return max(a, min(b, x)); }
+        public static uint clamp(uint valueToClamp, uint lowerBound, uint upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
-        /// <summary>Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are uint2 vectors.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The componentwise clamping of the input x into the interval [a, b].</returns>
+        /// <summary>Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are uint2 vectors.</summary>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The componentwise clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint2 clamp(uint2 x, uint2 a, uint2 b) { return max(a, min(b, x)); }
+        public static uint2 clamp(uint2 valueToClamp, uint2 lowerBound, uint2 upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
-        /// <summary>Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are uint3 vectors.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The componentwise clamping of the input x into the interval [a, b].</returns>
+        /// <summary>Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are uint3 vectors.</summary>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The componentwise clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint3 clamp(uint3 x, uint3 a, uint3 b) { return max(a, min(b, x)); }
+        public static uint3 clamp(uint3 valueToClamp, uint3 lowerBound, uint3 upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
-        /// <summary>Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are uint4 vectors.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The componentwise clamping of the input x into the interval [a, b].</returns>
+        /// <summary>Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are uint4 vectors.</summary>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The componentwise clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint4 clamp(uint4 x, uint4 a, uint4 b) { return max(a, min(b, x)); }
+        public static uint4 clamp(uint4 valueToClamp, uint4 lowerBound, uint4 upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
 
-        /// <summary>Returns the result of clamping the value x into the interval [a, b], where x, a and b are long values.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The clamping of the input x into the interval [a, b].</returns>
+        /// <summary>Returns the result of clamping the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are long values.</summary>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long clamp(long x, long a, long b) { return max(a, min(b, x)); }
+        public static long clamp(long valueToClamp, long lowerBound, long upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
-        /// <summary>Returns the result of clamping the value x into the interval [a, b], where x, a and b are ulong values.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The clamping of the input x into the interval [a, b].</returns>
+        /// <summary>Returns the result of clamping the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are ulong values.</summary>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ulong clamp(ulong x, ulong a, ulong b) { return max(a, min(b, x)); }
+        public static ulong clamp(ulong valueToClamp, ulong lowerBound, ulong upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
 
-        /// <summary>Returns the result of clamping the value x into the interval [a, b], where x, a and b are float values.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The clamping of the input x into the interval [a, b].</returns>
+        /// <summary>Returns the result of clamping the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are float values.</summary>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float clamp(float x, float a, float b) { return max(a, min(b, x)); }
+        public static float clamp(float valueToClamp, float lowerBound, float upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
-        /// <summary>Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are float2 vectors.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The componentwise clamping of the input x into the interval [a, b].</returns>
+        /// <summary>Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are float2 vectors.</summary>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The componentwise clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 clamp(float2 x, float2 a, float2 b) { return max(a, min(b, x)); }
+        public static float2 clamp(float2 valueToClamp, float2 lowerBound, float2 upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
-        /// <summary>Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are float3 vectors.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The componentwise clamping of the input x into the interval [a, b].</returns>
+        /// <summary>Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are float3 vectors.</summary>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The componentwise clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 clamp(float3 x, float3 a, float3 b) { return max(a, min(b, x)); }
+        public static float3 clamp(float3 valueToClamp, float3 lowerBound, float3 upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
-        /// <summary>Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are float4 vectors.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The componentwise clamping of the input x into the interval [a, b].</returns>
+        /// <summary>Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are float4 vectors.</summary>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The componentwise clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 clamp(float4 x, float4 a, float4 b) { return max(a, min(b, x)); }
+        public static float4 clamp(float4 valueToClamp, float4 lowerBound, float4 upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
 
-        /// <summary>Returns the result of clamping the value x into the interval [a, b], where x, a and b are double values.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The clamping of the input x into the interval [a, b].</returns>
+        /// <summary>Returns the result of clamping the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are double values.</summary>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double clamp(double x, double a, double b) { return max(a, min(b, x)); }
+        public static double clamp(double valueToClamp, double lowerBound, double upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
-        /// <summary>Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are double2 vectors.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The componentwise clamping of the input x into the interval [a, b].</returns>
+        /// <summary>Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are double2 vectors.</summary>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The componentwise clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double2 clamp(double2 x, double2 a, double2 b) { return max(a, min(b, x)); }
+        public static double2 clamp(double2 valueToClamp, double2 lowerBound, double2 upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
-        /// <summary>Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are double3 vectors.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The componentwise clamping of the input x into the interval [a, b].</returns>
+        /// <summary>Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are double3 vectors.</summary>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The componentwise clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double3 clamp(double3 x, double3 a, double3 b) { return max(a, min(b, x)); }
+        public static double3 clamp(double3 valueToClamp, double3 lowerBound, double3 upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
-        /// <summary>Returns the result of a componentwise clamping of the value x into the interval [a, b], where x, a and b are double4 vectors.</summary>
-        /// <param name="x">Input value to be clamped.</param>
-        /// <param name="a">Lower bound of the interval.</param>
-        /// <param name="b">Upper bound of the interval.</param>
-        /// <returns>The componentwise clamping of the input x into the interval [a, b].</returns>
+        /// <summary>Returns the result of a componentwise clamping of the value valueToClamp into the interval (inclusive) [lowerBound, upperBound], where valueToClamp, lowerBound and upperBound are double4 vectors.</summary>
+        /// <param name="valueToClamp">Input value to be clamped.</param>
+        /// <param name="lowerBound">Lower bound of the interval.</param>
+        /// <param name="upperBound">Upper bound of the interval.</param>
+        /// <returns>The componentwise clamping of the input valueToClamp into the interval (inclusive) [lowerBound, upperBound].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double4 clamp(double4 x, double4 a, double4 b) { return max(a, min(b, x)); }
+        public static double4 clamp(double4 valueToClamp, double4 lowerBound, double4 upperBound) { return max(lowerBound, min(upperBound, valueToClamp)); }
 
 
         /// <summary>Returns the result of clamping the float value x into the interval [0, 1].</summary>
@@ -3776,100 +3776,100 @@ public static bool4 ispow2(uint4 x)
         public static double3 cross(double3 x, double3 y) { return (x * y.yzx - x.yzx * y).yzx; }
 
 
-        /// <summary>Returns a smooth Hermite interpolation between 0.0f and 1.0f when x is in [a, b].</summary>
-        /// <param name="a">The minimum range of the x parameter.</param>
-        /// <param name="b">The maximum range of the x parameter.</param>
+        /// <summary>Returns a smooth Hermite interpolation between 0.0f and 1.0f when x is in the interval (inclusive) [xMin, xMax].</summary>
+        /// <param name="xMin">The minimum range of the x parameter.</param>
+        /// <param name="xMax">The maximum range of the x parameter.</param>
         /// <param name="x">The value to be interpolated.</param>
         /// <returns>Returns a value camped to the range [0, 1].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float smoothstep(float a, float b, float x)
+        public static float smoothstep(float xMin, float xMax, float x)
         {
-            var t = saturate((x - a) / (b - a));
+            var t = saturate((x - xMin) / (xMax - xMin));
             return t * t * (3.0f - (2.0f * t));
         }
 
-        /// <summary>Returns a componentwise smooth Hermite interpolation between 0.0f and 1.0f when x is in [a, b].</summary>
-        /// <param name="a">The minimum range of the x parameter.</param>
-        /// <param name="b">The maximum range of the x parameter.</param>
+        /// <summary>Returns a componentwise smooth Hermite interpolation between 0.0f and 1.0f when x is in the interval (inclusive) [xMin, xMax].</summary>
+        /// <param name="xMin">The minimum range of the x parameter.</param>
+        /// <param name="xMax">The maximum range of the x parameter.</param>
         /// <param name="x">The value to be interpolated.</param>
         /// <returns>Returns component values camped to the range [0, 1].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 smoothstep(float2 a, float2 b, float2 x)
+        public static float2 smoothstep(float2 xMin, float2 xMax, float2 x)
         {
-            var t = saturate((x - a) / (b - a));
+            var t = saturate((x - xMin) / (xMax - xMin));
             return t * t * (3.0f - (2.0f * t));
         }
 
-        /// <summary>Returns a componentwise smooth Hermite interpolation between 0.0f and 1.0f when x is in [a, b].</summary>
-        /// <param name="a">The minimum range of the x parameter.</param>
-        /// <param name="b">The maximum range of the x parameter.</param>
+        /// <summary>Returns a componentwise smooth Hermite interpolation between 0.0f and 1.0f when x is in the interval (inclusive) [xMin, xMax].</summary>
+        /// <param name="xMin">The minimum range of the x parameter.</param>
+        /// <param name="xMax">The maximum range of the x parameter.</param>
         /// <param name="x">The value to be interpolated.</param>
         /// <returns>Returns component values camped to the range [0, 1].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 smoothstep(float3 a, float3 b, float3 x)
+        public static float3 smoothstep(float3 xMin, float3 xMax, float3 x)
         {
-            var t = saturate((x - a) / (b - a));
+            var t = saturate((x - xMin) / (xMax - xMin));
             return t * t * (3.0f - (2.0f * t));
         }
 
-        /// <summary>Returns a componentwise smooth Hermite interpolation between 0.0f and 1.0f when x is in [a, b].</summary>
-        /// <param name="a">The minimum range of the x parameter.</param>
-        /// <param name="b">The maximum range of the x parameter.</param>
+        /// <summary>Returns a componentwise smooth Hermite interpolation between 0.0f and 1.0f when x is in the interval (inclusive) [xMin, xMax].</summary>
+        /// <param name="xMin">The minimum range of the x parameter.</param>
+        /// <param name="xMax">The maximum range of the x parameter.</param>
         /// <param name="x">The value to be interpolated.</param>
         /// <returns>Returns component values camped to the range [0, 1].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 smoothstep(float4 a, float4 b, float4 x)
+        public static float4 smoothstep(float4 xMin, float4 xMax, float4 x)
         {
-            var t = saturate((x - a) / (b - a));
+            var t = saturate((x - xMin) / (xMax - xMin));
             return t * t * (3.0f - (2.0f * t));
         }
 
 
-        /// <summary>Returns a smooth Hermite interpolation between 0.0 and 1.0 when x is in [a, b].</summary>
-        /// <param name="a">The minimum range of the x parameter.</param>
-        /// <param name="b">The maximum range of the x parameter.</param>
+        /// <summary>Returns a smooth Hermite interpolation between 0.0 and 1.0 when x is in the interval (inclusive) [xMin, xMax].</summary>
+        /// <param name="xMin">The minimum range of the x parameter.</param>
+        /// <param name="xMax">The maximum range of the x parameter.</param>
         /// <param name="x">The value to be interpolated.</param>
         /// <returns>Returns a value camped to the range [0, 1].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double smoothstep(double a, double b, double x)
+        public static double smoothstep(double xMin, double xMax, double x)
         {
-            var t = saturate((x - a) / (b - a));
+            var t = saturate((x - xMin) / (xMax - xMin));
             return t * t * (3.0 - (2.0 * t));
         }
 
-        /// <summary>Returns a componentwise smooth Hermite interpolation between 0.0 and 1.0 when x is in [a, b].</summary>
-        /// <param name="a">The minimum range of the x parameter.</param>
-        /// <param name="b">The maximum range of the x parameter.</param>
+        /// <summary>Returns a componentwise smooth Hermite interpolation between 0.0 and 1.0 when x is in the interval (inclusive) [xMin, xMax].</summary>
+        /// <param name="xMin">The minimum range of the x parameter.</param>
+        /// <param name="xMax">The maximum range of the x parameter.</param>
         /// <param name="x">The value to be interpolated.</param>
         /// <returns>Returns component values camped to the range [0, 1].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double2 smoothstep(double2 a, double2 b, double2 x)
+        public static double2 smoothstep(double2 xMin, double2 xMax, double2 x)
         {
-            var t = saturate((x - a) / (b - a));
+            var t = saturate((x - xMin) / (xMax - xMin));
             return t * t * (3.0 - (2.0 * t));
         }
 
-        /// <summary>Returns a componentwise smooth Hermite interpolation between 0.0 and 1.0 when x is in [a, b].</summary>
-        /// <param name="a">The minimum range of the x parameter.</param>
-        /// <param name="b">The maximum range of the x parameter.</param>
+        /// <summary>Returns a componentwise smooth Hermite interpolation between 0.0 and 1.0 when x is in the interval (inclusive) [xMin, xMax].</summary>
+        /// <param name="xMin">The minimum range of the x parameter.</param>
+        /// <param name="xMax">The maximum range of the x parameter.</param>
         /// <param name="x">The value to be interpolated.</param>
         /// <returns>Returns component values camped to the range [0, 1].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double3 smoothstep(double3 a, double3 b, double3 x)
+        public static double3 smoothstep(double3 xMin, double3 xMax, double3 x)
         {
-            var t = saturate((x - a) / (b - a));
+            var t = saturate((x - xMin) / (xMax - xMin));
             return t * t * (3.0 - (2.0 * t));
         }
 
-        /// <summary>Returns a componentwise smooth Hermite interpolation between 0.0 and 1.0 when x is in [a, b].</summary>
-        /// <param name="a">The minimum range of the x parameter.</param>
-        /// <param name="b">The maximum range of the x parameter.</param>
+        /// <summary>Returns a componentwise smooth Hermite interpolation between 0.0 and 1.0 when x is in the interval (inclusive) [xMin, xMax].</summary>
+        /// <param name="xMin">The minimum range of the x parameter.</param>
+        /// <param name="xMax">The maximum range of the x parameter.</param>
         /// <param name="x">The value to be interpolated.</param>
         /// <returns>Returns component values camped to the range [0, 1].</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double4 smoothstep(double4 a, double4 b, double4 x)
+        public static double4 smoothstep(double4 xMin, double4 xMax, double4 x)
         {
-            var t = saturate((x - a) / (b - a));
+            var t = saturate((x - xMin) / (xMax - xMin));
             return t * t * (3.0 - (2.0 * t));
         }
 
@@ -4064,346 +4064,346 @@ public static double4 smoothstep(double4 a, double4 b, double4 x)
         public static bool all(double4 x) { return x.x != 0.0 && x.y != 0.0 && x.z != 0.0 && x.w != 0.0; }
 
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int select(int a, int b, bool c)    { return c ? b : a; }
+        public static int select(int falseValue, int trueValue, bool test)    { return test ? trueValue : falseValue; }
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int2 select(int2 a, int2 b, bool c) { return c ? b : a; }
+        public static int2 select(int2 falseValue, int2 trueValue, bool test) { return test ? trueValue : falseValue; }
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int3 select(int3 a, int3 b, bool c) { return c ? b : a; }
+        public static int3 select(int3 falseValue, int3 trueValue, bool test) { return test ? trueValue : falseValue; }
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int4 select(int4 a, int4 b, bool c) { return c ? b : a; }
+        public static int4 select(int4 falseValue, int4 trueValue, bool test) { return test ? trueValue : falseValue; }
 
 
         /// <summary>
-        /// Returns a componentwise selection between two double4 vectors a and b based on a bool4 selection mask c.
-        /// Per component, the component from b is selected when c is true, otherwise the component from a is selected.
+        /// Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test.
+        /// Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected.
         /// </summary>
-        /// <param name="a">Values to use if c is false.</param>
-        /// <param name="b">Values to use if c is true.</param>
-        /// <param name="c">Selection mask to choose between a and b.</param>
-        /// <returns>The componentwise selection between a and b according to selection mask c.</returns>
+        /// <param name="falseValue">Values to use if test is false.</param>
+        /// <param name="trueValue">Values to use if test is true.</param>
+        /// <param name="test">Selection mask to choose between falseValue and trueValue.</param>
+        /// <returns>The componentwise selection between falseValue and trueValue according to selection mask test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int2 select(int2 a, int2 b, bool2 c) { return new int2(c.x ? b.x : a.x, c.y ? b.y : a.y); }
+        public static int2 select(int2 falseValue, int2 trueValue, bool2 test) { return new int2(test.x ? trueValue.x : falseValue.x, test.y ? trueValue.y : falseValue.y); }
 
         /// <summary>
-        /// Returns a componentwise selection between two double4 vectors a and b based on a bool4 selection mask c.
-        /// Per component, the component from b is selected when c is true, otherwise the component from a is selected.
+        /// Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test.
+        /// Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected.
         /// </summary>
-        /// <param name="a">Values to use if c is false.</param>
-        /// <param name="b">Values to use if c is true.</param>
-        /// <param name="c">Selection mask to choose between a and b.</param>
-        /// <returns>The componentwise selection between a and b according to selection mask c.</returns>
+        /// <param name="falseValue">Values to use if test is false.</param>
+        /// <param name="trueValue">Values to use if test is true.</param>
+        /// <param name="test">Selection mask to choose between falseValue and trueValue.</param>
+        /// <returns>The componentwise selection between falseValue and trueValue according to selection mask test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int3 select(int3 a, int3 b, bool3 c) { return new int3(c.x ? b.x : a.x, c.y ? b.y : a.y, c.z ? b.z : a.z); }
+        public static int3 select(int3 falseValue, int3 trueValue, bool3 test) { return new int3(test.x ? trueValue.x : falseValue.x, test.y ? trueValue.y : falseValue.y, test.z ? trueValue.z : falseValue.z); }
 
         /// <summary>
-        /// Returns a componentwise selection between two double4 vectors a and b based on a bool4 selection mask c.
-        /// Per component, the component from b is selected when c is true, otherwise the component from a is selected.
+        /// Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test.
+        /// Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected.
         /// </summary>
-        /// <param name="a">Values to use if c is false.</param>
-        /// <param name="b">Values to use if c is true.</param>
-        /// <param name="c">Selection mask to choose between a and b.</param>
-        /// <returns>The componentwise selection between a and b according to selection mask c.</returns>
+        /// <param name="falseValue">Values to use if test is false.</param>
+        /// <param name="trueValue">Values to use if test is true.</param>
+        /// <param name="test">Selection mask to choose between falseValue and trueValue.</param>
+        /// <returns>The componentwise selection between falseValue and trueValue according to selection mask test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int4 select(int4 a, int4 b, bool4 c) { return new int4(c.x ? b.x : a.x, c.y ? b.y : a.y, c.z ? b.z : a.z, c.w ? b.w : a.w); }
+        public static int4 select(int4 falseValue, int4 trueValue, bool4 test) { return new int4(test.x ? trueValue.x : falseValue.x, test.y ? trueValue.y : falseValue.y, test.z ? trueValue.z : falseValue.z, test.w ? trueValue.w : falseValue.w); }
 
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint select(uint a, uint b, bool c) { return c ? b : a; }
+        public static uint select(uint falseValue, uint trueValue, bool test) { return test ? trueValue : falseValue; }
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint2 select(uint2 a, uint2 b, bool c) { return c ? b : a; }
+        public static uint2 select(uint2 falseValue, uint2 trueValue, bool test) { return test ? trueValue : falseValue; }
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint3 select(uint3 a, uint3 b, bool c) { return c ? b : a; }
+        public static uint3 select(uint3 falseValue, uint3 trueValue, bool test) { return test ? trueValue : falseValue; }
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint4 select(uint4 a, uint4 b, bool c) { return c ? b : a; }
+        public static uint4 select(uint4 falseValue, uint4 trueValue, bool test) { return test ? trueValue : falseValue; }
 
 
         /// <summary>
-        /// Returns a componentwise selection between two double4 vectors a and b based on a bool4 selection mask c.
-        /// Per component, the component from b is selected when c is true, otherwise the component from a is selected.
+        /// Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test.
+        /// Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected.
         /// </summary>
-        /// <param name="a">Values to use if c is false.</param>
-        /// <param name="b">Values to use if c is true.</param>
-        /// <param name="c">Selection mask to choose between a and b.</param>
-        /// <returns>The componentwise selection between a and b according to selection mask c.</returns>
+        /// <param name="falseValue">Values to use if test is false.</param>
+        /// <param name="trueValue">Values to use if test is true.</param>
+        /// <param name="test">Selection mask to choose between falseValue and trueValue.</param>
+        /// <returns>The componentwise selection between falseValue and trueValue according to selection mask test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint2 select(uint2 a, uint2 b, bool2 c) { return new uint2(c.x ? b.x : a.x, c.y ? b.y : a.y); }
+        public static uint2 select(uint2 falseValue, uint2 trueValue, bool2 test) { return new uint2(test.x ? trueValue.x : falseValue.x, test.y ? trueValue.y : falseValue.y); }
 
         /// <summary>
-        /// Returns a componentwise selection between two double4 vectors a and b based on a bool4 selection mask c.
-        /// Per component, the component from b is selected when c is true, otherwise the component from a is selected.
+        /// Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test.
+        /// Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected.
         /// </summary>
-        /// <param name="a">Values to use if c is false.</param>
-        /// <param name="b">Values to use if c is true.</param>
-        /// <param name="c">Selection mask to choose between a and b.</param>
-        /// <returns>The componentwise selection between a and b according to selection mask c.</returns>
+        /// <param name="falseValue">Values to use if test is false.</param>
+        /// <param name="trueValue">Values to use if test is true.</param>
+        /// <param name="test">Selection mask to choose between falseValue and trueValue.</param>
+        /// <returns>The componentwise selection between falseValue and trueValue according to selection mask test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint3 select(uint3 a, uint3 b, bool3 c) { return new uint3(c.x ? b.x : a.x, c.y ? b.y : a.y, c.z ? b.z : a.z); }
+        public static uint3 select(uint3 falseValue, uint3 trueValue, bool3 test) { return new uint3(test.x ? trueValue.x : falseValue.x, test.y ? trueValue.y : falseValue.y, test.z ? trueValue.z : falseValue.z); }
 
         /// <summary>
-        /// Returns a componentwise selection between two double4 vectors a and b based on a bool4 selection mask c.
-        /// Per component, the component from b is selected when c is true, otherwise the component from a is selected.
+        /// Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test.
+        /// Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected.
         /// </summary>
-        /// <param name="a">Values to use if c is false.</param>
-        /// <param name="b">Values to use if c is true.</param>
-        /// <param name="c">Selection mask to choose between a and b.</param>
-        /// <returns>The componentwise selection between a and b according to selection mask c.</returns>
+        /// <param name="falseValue">Values to use if test is false.</param>
+        /// <param name="trueValue">Values to use if test is true.</param>
+        /// <param name="test">Selection mask to choose between falseValue and trueValue.</param>
+        /// <returns>The componentwise selection between falseValue and trueValue according to selection mask test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint4 select(uint4 a, uint4 b, bool4 c) { return new uint4(c.x ? b.x : a.x, c.y ? b.y : a.y, c.z ? b.z : a.z, c.w ? b.w : a.w); }
+        public static uint4 select(uint4 falseValue, uint4 trueValue, bool4 test) { return new uint4(test.x ? trueValue.x : falseValue.x, test.y ? trueValue.y : falseValue.y, test.z ? trueValue.z : falseValue.z, test.w ? trueValue.w : falseValue.w); }
 
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static long select(long a, long b, bool c) { return c ? b : a; }
+        public static long select(long falseValue, long trueValue, bool test) { return test ? trueValue : falseValue; }
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static ulong select(ulong a, ulong b, bool c) { return c ? b : a; }
+        public static ulong select(ulong falseValue, ulong trueValue, bool test) { return test ? trueValue : falseValue; }
 
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float select(float a, float b, bool c)    { return c ? b : a; }
+        public static float select(float falseValue, float trueValue, bool test)    { return test ? trueValue : falseValue; }
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 select(float2 a, float2 b, bool c) { return c ? b : a; }
+        public static float2 select(float2 falseValue, float2 trueValue, bool test) { return test ? trueValue : falseValue; }
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 select(float3 a, float3 b, bool c) { return c ? b : a; }
+        public static float3 select(float3 falseValue, float3 trueValue, bool test) { return test ? trueValue : falseValue; }
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 select(float4 a, float4 b, bool c) { return c ? b : a; }
+        public static float4 select(float4 falseValue, float4 trueValue, bool test) { return test ? trueValue : falseValue; }
 
 
         /// <summary>
-        /// Returns a componentwise selection between two double4 vectors a and b based on a bool4 selection mask c.
-        /// Per component, the component from b is selected when c is true, otherwise the component from a is selected.
+        /// Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test.
+        /// Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected.
         /// </summary>
-        /// <param name="a">Values to use if c is false.</param>
-        /// <param name="b">Values to use if c is true.</param>
-        /// <param name="c">Selection mask to choose between a and b.</param>
-        /// <returns>The componentwise selection between a and b according to selection mask c.</returns>
+        /// <param name="falseValue">Values to use if test is false.</param>
+        /// <param name="trueValue">Values to use if test is true.</param>
+        /// <param name="test">Selection mask to choose between falseValue and trueValue.</param>
+        /// <returns>The componentwise selection between falseValue and trueValue according to selection mask test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 select(float2 a, float2 b, bool2 c) { return new float2(c.x ? b.x : a.x, c.y ? b.y : a.y); }
+        public static float2 select(float2 falseValue, float2 trueValue, bool2 test) { return new float2(test.x ? trueValue.x : falseValue.x, test.y ? trueValue.y : falseValue.y); }
 
         /// <summary>
-        /// Returns a componentwise selection between two double4 vectors a and b based on a bool4 selection mask c.
-        /// Per component, the component from b is selected when c is true, otherwise the component from a is selected.
+        /// Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test.
+        /// Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected.
         /// </summary>
-        /// <param name="a">Values to use if c is false.</param>
-        /// <param name="b">Values to use if c is true.</param>
-        /// <param name="c">Selection mask to choose between a and b.</param>
-        /// <returns>The componentwise selection between a and b according to selection mask c.</returns>
+        /// <param name="falseValue">Values to use if test is false.</param>
+        /// <param name="trueValue">Values to use if test is true.</param>
+        /// <param name="test">Selection mask to choose between falseValue and trueValue.</param>
+        /// <returns>The componentwise selection between falseValue and trueValue according to selection mask test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 select(float3 a, float3 b, bool3 c) { return new float3(c.x ? b.x : a.x, c.y ? b.y : a.y, c.z ? b.z : a.z); }
+        public static float3 select(float3 falseValue, float3 trueValue, bool3 test) { return new float3(test.x ? trueValue.x : falseValue.x, test.y ? trueValue.y : falseValue.y, test.z ? trueValue.z : falseValue.z); }
 
         /// <summary>
-        /// Returns a componentwise selection between two double4 vectors a and b based on a bool4 selection mask c.
-        /// Per component, the component from b is selected when c is true, otherwise the component from a is selected.
+        /// Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test.
+        /// Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected.
         /// </summary>
-        /// <param name="a">Values to use if c is false.</param>
-        /// <param name="b">Values to use if c is true.</param>
-        /// <param name="c">Selection mask to choose between a and b.</param>
-        /// <returns>The componentwise selection between a and b according to selection mask c.</returns>
+        /// <param name="falseValue">Values to use if test is false.</param>
+        /// <param name="trueValue">Values to use if test is true.</param>
+        /// <param name="test">Selection mask to choose between falseValue and trueValue.</param>
+        /// <returns>The componentwise selection between falseValue and trueValue according to selection mask test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 select(float4 a, float4 b, bool4 c) { return new float4(c.x ? b.x : a.x, c.y ? b.y : a.y, c.z ? b.z : a.z, c.w ? b.w : a.w); }
+        public static float4 select(float4 falseValue, float4 trueValue, bool4 test) { return new float4(test.x ? trueValue.x : falseValue.x, test.y ? trueValue.y : falseValue.y, test.z ? trueValue.z : falseValue.z, test.w ? trueValue.w : falseValue.w); }
 
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double select(double a, double b, bool c) { return c ? b : a; }
+        public static double select(double falseValue, double trueValue, bool test) { return test ? trueValue : falseValue; }
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double2 select(double2 a, double2 b, bool c) { return c ? b : a; }
+        public static double2 select(double2 falseValue, double2 trueValue, bool test) { return test ? trueValue : falseValue; }
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double3 select(double3 a, double3 b, bool c) { return c ? b : a; }
+        public static double3 select(double3 falseValue, double3 trueValue, bool test) { return test ? trueValue : falseValue; }
 
-        /// <summary>Returns b if c is true, a otherwise.</summary>
-        /// <param name="a">Value to use if c is false.</param>
-        /// <param name="b">Value to use if c is true.</param>
-        /// <param name="c">Bool value to choose between a and b.</param>
-        /// <returns>The selection between a and b according to bool c.</returns>
+        /// <summary>Returns trueValue if test is true, falseValue otherwise.</summary>
+        /// <param name="falseValue">Value to use if test is false.</param>
+        /// <param name="trueValue">Value to use if test is true.</param>
+        /// <param name="test">Bool value to choose between falseValue and trueValue.</param>
+        /// <returns>The selection between falseValue and trueValue according to bool test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double4 select(double4 a, double4 b, bool c) { return c ? b : a; }
+        public static double4 select(double4 falseValue, double4 trueValue, bool test) { return test ? trueValue : falseValue; }
 
         /// <summary>
-        /// Returns a componentwise selection between two double4 vectors a and b based on a bool4 selection mask c.
-        /// Per component, the component from b is selected when c is true, otherwise the component from a is selected.
+        /// Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test.
+        /// Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected.
         /// </summary>
-        /// <param name="a">Values to use if c is false.</param>
-        /// <param name="b">Values to use if c is true.</param>
-        /// <param name="c">Selection mask to choose between a and b.</param>
-        /// <returns>The componentwise selection between a and b according to selection mask c.</returns>
+        /// <param name="falseValue">Values to use if test is false.</param>
+        /// <param name="trueValue">Values to use if test is true.</param>
+        /// <param name="test">Selection mask to choose between falseValue and trueValue.</param>
+        /// <returns>The componentwise selection between falseValue and trueValue according to selection mask test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double2 select(double2 a, double2 b, bool2 c) { return new double2(c.x ? b.x : a.x, c.y ? b.y : a.y); }
+        public static double2 select(double2 falseValue, double2 trueValue, bool2 test) { return new double2(test.x ? trueValue.x : falseValue.x, test.y ? trueValue.y : falseValue.y); }
 
         /// <summary>
-        /// Returns a componentwise selection between two double4 vectors a and b based on a bool4 selection mask c.
-        /// Per component, the component from b is selected when c is true, otherwise the component from a is selected.
+        /// Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test.
+        /// Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected.
         /// </summary>
-        /// <param name="a">Values to use if c is false.</param>
-        /// <param name="b">Values to use if c is true.</param>
-        /// <param name="c">Selection mask to choose between a and b.</param>
-        /// <returns>The componentwise selection between a and b according to selection mask c.</returns>
+        /// <param name="falseValue">Values to use if test is false.</param>
+        /// <param name="trueValue">Values to use if test is true.</param>
+        /// <param name="test">Selection mask to choose between falseValue and trueValue.</param>
+        /// <returns>The componentwise selection between falseValue and trueValue according to selection mask test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double3 select(double3 a, double3 b, bool3 c) { return new double3(c.x ? b.x : a.x, c.y ? b.y : a.y, c.z ? b.z : a.z); }
+        public static double3 select(double3 falseValue, double3 trueValue, bool3 test) { return new double3(test.x ? trueValue.x : falseValue.x, test.y ? trueValue.y : falseValue.y, test.z ? trueValue.z : falseValue.z); }
 
         /// <summary>
-        /// Returns a componentwise selection between two double4 vectors a and b based on a bool4 selection mask c.
-        /// Per component, the component from b is selected when c is true, otherwise the component from a is selected.
+        /// Returns a componentwise selection between two double4 vectors falseValue and trueValue based on a bool4 selection mask test.
+        /// Per component, the component from trueValue is selected when test is true, otherwise the component from falseValue is selected.
         /// </summary>
-        /// <param name="a">Values to use if c is false.</param>
-        /// <param name="b">Values to use if c is true.</param>
-        /// <param name="c">Selection mask to choose between a and b.</param>
-        /// <returns>The componentwise selection between a and b according to selection mask c.</returns>
+        /// <param name="falseValue">Values to use if test is false.</param>
+        /// <param name="trueValue">Values to use if test is true.</param>
+        /// <param name="test">Selection mask to choose between falseValue and trueValue.</param>
+        /// <returns>The componentwise selection between falseValue and trueValue according to selection mask test.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double4 select(double4 a, double4 b, bool4 c) { return new double4(c.x ? b.x : a.x, c.y ? b.y : a.y, c.z ? b.z : a.z, c.w ? b.w : a.w); }
+        public static double4 select(double4 falseValue, double4 trueValue, bool4 test) { return new double4(test.x ? trueValue.x : falseValue.x, test.y ? trueValue.y : falseValue.y, test.z ? trueValue.z : falseValue.z, test.w ? trueValue.w : falseValue.w); }
 
 
-        /// <summary>Returns the result of a step function where the result is 1.0f when x &gt;= y and 0.0f otherwise.</summary>
-        /// <param name="y">Value to be used as a threshold for returning 1.</param>
-        /// <param name="x">Value to compare against threshold y.</param>
-        /// <returns>1 if the comparison x &gt;= y is true, otherwise 0.</returns>
+        /// <summary>Returns the result of a step function where the result is 1.0f when x &gt;= threshold and 0.0f otherwise.</summary>
+        /// <param name="threshold">Value to be used as a threshold for returning 1.</param>
+        /// <param name="x">Value to compare against threshold.</param>
+        /// <returns>1 if the comparison x &gt;= threshold is true, otherwise 0.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float step(float y, float x) { return select(0.0f, 1.0f, x >= y); }
+        public static float step(float threshold, float x) { return select(0.0f, 1.0f, x >= threshold); }
 
-        /// <summary>Returns the result of a componentwise step function where each component is 1.0f when x &gt;= y and 0.0f otherwise.</summary>
-        /// <param name="y">Vector of values to be used as a threshold for returning 1.</param>
-        /// <param name="x">Vector of values to compare against threshold y.</param>
-        /// <returns>1 if the componentwise comparison x &gt;= y is true, otherwise 0.</returns>
+        /// <summary>Returns the result of a componentwise step function where each component is 1.0f when x &gt;= threshold and 0.0f otherwise.</summary>
+        /// <param name="threshold">Vector of values to be used as a threshold for returning 1.</param>
+        /// <param name="x">Vector of values to compare against threshold.</param>
+        /// <returns>1 if the componentwise comparison x &gt;= threshold is true, otherwise 0.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 step(float2 y, float2 x) { return select(float2(0.0f), float2(1.0f), x >= y); }
+        public static float2 step(float2 threshold, float2 x) { return select(float2(0.0f), float2(1.0f), x >= threshold); }
 
-        /// <summary>Returns the result of a componentwise step function where each component is 1.0f when x &gt;= y and 0.0f otherwise.</summary>
-        /// <param name="y">Vector of values to be used as a threshold for returning 1.</param>
-        /// <param name="x">Vector of values to compare against threshold y.</param>
-        /// <returns>1 if the componentwise comparison x &gt;= y is true, otherwise 0.</returns>
+        /// <summary>Returns the result of a componentwise step function where each component is 1.0f when x &gt;= threshold and 0.0f otherwise.</summary>
+        /// <param name="threshold">Vector of values to be used as a threshold for returning 1.</param>
+        /// <param name="x">Vector of values to compare against threshold.</param>
+        /// <returns>1 if the componentwise comparison x &gt;= threshold is true, otherwise 0.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 step(float3 y, float3 x) { return select(float3(0.0f), float3(1.0f), x >= y); }
+        public static float3 step(float3 threshold, float3 x) { return select(float3(0.0f), float3(1.0f), x >= threshold); }
 
-        /// <summary>Returns the result of a componentwise step function where each component is 1.0f when x &gt;= y and 0.0f otherwise.</summary>
-        /// <param name="y">Vector of values to be used as a threshold for returning 1.</param>
-        /// <param name="x">Vector of values to compare against threshold y.</param>
-        /// <returns>1 if the componentwise comparison x &gt;= y is true, otherwise 0.</returns>
+        /// <summary>Returns the result of a componentwise step function where each component is 1.0f when x &gt;= threshold and 0.0f otherwise.</summary>
+        /// <param name="threshold">Vector of values to be used as a threshold for returning 1.</param>
+        /// <param name="x">Vector of values to compare against threshold.</param>
+        /// <returns>1 if the componentwise comparison x &gt;= threshold is true, otherwise 0.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 step(float4 y, float4 x) { return select(float4(0.0f), float4(1.0f), x >= y); }
+        public static float4 step(float4 threshold, float4 x) { return select(float4(0.0f), float4(1.0f), x >= threshold); }
 
 
-        /// <summary>Returns the result of a step function where the result is 1.0f when x &gt;= y and 0.0f otherwise.</summary>
-        /// <param name="y">Values to be used as a threshold for returning 1.</param>
-        /// <param name="x">Values to compare against threshold y.</param>
-        /// <returns>1 if the comparison x &gt;= y is true, otherwise 0.</returns>
+        /// <summary>Returns the result of a step function where the result is 1.0f when x &gt;= threshold and 0.0f otherwise.</summary>
+        /// <param name="threshold">Values to be used as a threshold for returning 1.</param>
+        /// <param name="x">Value to compare against threshold.</param>
+        /// <returns>1 if the comparison x &gt;= threshold is true, otherwise 0.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double step(double y, double x) { return select(0.0, 1.0, x >= y); }
+        public static double step(double threshold, double x) { return select(0.0, 1.0, x >= threshold); }
 
-        /// <summary>Returns the result of a componentwise step function where each component is 1.0f when x &gt;= y and 0.0f otherwise.</summary>
-        /// <param name="y">Vector of values to be used as a threshold for returning 1.</param>
-        /// <param name="x">Vector of values to compare against threshold y.</param>
-        /// <returns>1 if the componentwise comparison x &gt;= y is true, otherwise 0.</returns>
+        /// <summary>Returns the result of a componentwise step function where each component is 1.0f when x &gt;= threshold and 0.0f otherwise.</summary>
+        /// <param name="threshold">Vector of values to be used as a threshold for returning 1.</param>
+        /// <param name="x">Vector of values to compare against threshold.</param>
+        /// <returns>1 if the componentwise comparison x &gt;= threshold is true, otherwise 0.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double2 step(double2 y, double2 x) { return select(double2(0.0), double2(1.0), x >= y); }
+        public static double2 step(double2 threshold, double2 x) { return select(double2(0.0), double2(1.0), x >= threshold); }
 
-        /// <summary>Returns the result of a componentwise step function where each component is 1.0f when x &gt;= y and 0.0f otherwise.</summary>
-        /// <param name="y">Vector of values to be used as a threshold for returning 1.</param>
-        /// <param name="x">Vector of values to compare against threshold y.</param>
-        /// <returns>1 if the componentwise comparison x &gt;= y is true, otherwise 0.</returns>
+        /// <summary>Returns the result of a componentwise step function where each component is 1.0f when x &gt;= threshold and 0.0f otherwise.</summary>
+        /// <param name="threshold">Vector of values to be used as a threshold for returning 1.</param>
+        /// <param name="x">Vector of values to compare against threshold.</param>
+        /// <returns>1 if the componentwise comparison x &gt;= threshold is true, otherwise 0.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double3 step(double3 y, double3 x) { return select(double3(0.0), double3(1.0), x >= y); }
+        public static double3 step(double3 threshold, double3 x) { return select(double3(0.0), double3(1.0), x >= threshold); }
 
-        /// <summary>Returns the result of a componentwise step function where each component is 1.0f when x &gt;= y and 0.0f otherwise.</summary>
-        /// <param name="y">Vector of values to be used as a threshold for returning 1.</param>
-        /// <param name="x">Vector of values to compare against threshold y.</param>
-        /// <returns>1 if the componentwise comparison x &gt;= y is true, otherwise 0.</returns>
+        /// <summary>Returns the result of a componentwise step function where each component is 1.0f when x &gt;= threshold and 0.0f otherwise.</summary>
+        /// <param name="threshold">Vector of values to be used as a threshold for returning 1.</param>
+        /// <param name="x">Vector of values to compare against threshold.</param>
+        /// <returns>1 if the componentwise comparison x &gt;= threshold is true, otherwise 0.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double4 step(double4 y, double4 x) { return select(double4(0.0), double4(1.0), x >= y); }
+        public static double4 step(double4 threshold, double4 x) { return select(double4(0.0), double4(1.0), x >= threshold); }
 
 
         /// <summary>Given an incident vector i and a normal vector n, returns the reflection vector r = i - 2.0f * dot(i, n) * n.</summary>
@@ -4450,83 +4450,83 @@ public static double4 smoothstep(double4 a, double4 b, double4 x)
         public static double4 reflect(double4 i, double4 n) { return i - 2 * n * dot(i, n); }
 
 
-        /// <summary>Returns the refraction vector given the incident vector i, the normal vector n and the refraction index eta.</summary>
+        /// <summary>Returns the refraction vector given the incident vector i, the normal vector n and the refraction index.</summary>
         /// <param name="i">Incident vector.</param>
         /// <param name="n">Normal vector.</param>
-        /// <param name="eta">Index of refraction.</param>
+        /// <param name="indexOfRefraction">Index of refraction.</param>
         /// <returns>Refraction vector.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 refract(float2 i, float2 n, float eta)
+        public static float2 refract(float2 i, float2 n, float indexOfRefraction)
         {
             float ni = dot(n, i);
-            float k = 1.0f - eta * eta * (1.0f - ni * ni);
-            return select(0.0f, eta * i - (eta * ni + sqrt(k)) * n, k >= 0);
+            float k = 1.0f - indexOfRefraction * indexOfRefraction * (1.0f - ni * ni);
+            return select(0.0f, indexOfRefraction * i - (indexOfRefraction * ni + sqrt(k)) * n, k >= 0);
         }
 
-        /// <summary>Returns the refraction vector given the incident vector i, the normal vector n and the refraction index eta.</summary>
+        /// <summary>Returns the refraction vector given the incident vector i, the normal vector n and the refraction index.</summary>
         /// <param name="i">Incident vector.</param>
         /// <param name="n">Normal vector.</param>
-        /// <param name="eta">Index of refraction.</param>
+        /// <param name="indexOfRefraction">Index of refraction.</param>
         /// <returns>Refraction vector.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 refract(float3 i, float3 n, float eta)
+        public static float3 refract(float3 i, float3 n, float indexOfRefraction)
         {
             float ni = dot(n, i);
-            float k = 1.0f - eta * eta * (1.0f - ni * ni);
-            return select(0.0f, eta * i - (eta * ni + sqrt(k)) * n, k >= 0);
+            float k = 1.0f - indexOfRefraction * indexOfRefraction * (1.0f - ni * ni);
+            return select(0.0f, indexOfRefraction * i - (indexOfRefraction * ni + sqrt(k)) * n, k >= 0);
         }
 
-        /// <summary>Returns the refraction vector given the incident vector i, the normal vector n and the refraction index eta.</summary>
+        /// <summary>Returns the refraction vector given the incident vector i, the normal vector n and the refraction index.</summary>
         /// <param name="i">Incident vector.</param>
         /// <param name="n">Normal vector.</param>
-        /// <param name="eta">Index of refraction.</param>
+        /// <param name="indexOfRefraction">Index of refraction.</param>
         /// <returns>Refraction vector.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 refract(float4 i, float4 n, float eta)
+        public static float4 refract(float4 i, float4 n, float indexOfRefraction)
         {
             float ni = dot(n, i);
-            float k = 1.0f - eta * eta * (1.0f - ni * ni);
-            return select(0.0f, eta * i - (eta * ni + sqrt(k)) * n, k >= 0);
+            float k = 1.0f - indexOfRefraction * indexOfRefraction * (1.0f - ni * ni);
+            return select(0.0f, indexOfRefraction * i - (indexOfRefraction * ni + sqrt(k)) * n, k >= 0);
         }
 
 
-        /// <summary>Returns the refraction vector given the incident vector i, the normal vector n and the refraction index eta.</summary>
+        /// <summary>Returns the refraction vector given the incident vector i, the normal vector n and the refraction index.</summary>
         /// <param name="i">Incident vector.</param>
         /// <param name="n">Normal vector.</param>
-        /// <param name="eta">Index of refraction.</param>
+        /// <param name="indexOfRefraction">Index of refraction.</param>
         /// <returns>Refraction vector.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double2 refract(double2 i, double2 n, double eta)
+        public static double2 refract(double2 i, double2 n, double indexOfRefraction)
         {
             double ni = dot(n, i);
-            double k = 1.0 - eta * eta * (1.0 - ni * ni);
-            return select(0.0f, eta * i - (eta * ni + sqrt(k)) * n, k >= 0);
+            double k = 1.0 - indexOfRefraction * indexOfRefraction * (1.0 - ni * ni);
+            return select(0.0f, indexOfRefraction * i - (indexOfRefraction * ni + sqrt(k)) * n, k >= 0);
         }
 
-        /// <summary>Returns the refraction vector given the incident vector i, the normal vector n and the refraction index eta.</summary>
+        /// <summary>Returns the refraction vector given the incident vector i, the normal vector n and the refraction index.</summary>
         /// <param name="i">Incident vector.</param>
         /// <param name="n">Normal vector.</param>
-        /// <param name="eta">Index of refraction.</param>
+        /// <param name="indexOfRefraction">Index of refraction.</param>
         /// <returns>Refraction vector.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double3 refract(double3 i, double3 n, double eta)
+        public static double3 refract(double3 i, double3 n, double indexOfRefraction)
         {
             double ni = dot(n, i);
-            double k = 1.0 - eta * eta * (1.0 - ni * ni);
-            return select(0.0f, eta * i - (eta * ni + sqrt(k)) * n, k >= 0);
+            double k = 1.0 - indexOfRefraction * indexOfRefraction * (1.0 - ni * ni);
+            return select(0.0f, indexOfRefraction * i - (indexOfRefraction * ni + sqrt(k)) * n, k >= 0);
         }
 
-        /// <summary>Returns the refraction vector given the incident vector i, the normal vector n and the refraction index eta.</summary>
+        /// <summary>Returns the refraction vector given the incident vector i, the normal vector n and the refraction index.</summary>
         /// <param name="i">Incident vector.</param>
         /// <param name="n">Normal vector.</param>
-        /// <param name="eta">Index of refraction.</param>
+        /// <param name="indexOfRefraction">Index of refraction.</param>
         /// <returns>Refraction vector.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double4 refract(double4 i, double4 n, double eta)
+        public static double4 refract(double4 i, double4 n, double indexOfRefraction)
         {
             double ni = dot(n, i);
-            double k = 1.0 - eta * eta * (1.0 - ni * ni);
-            return select(0.0f, eta * i - (eta * ni + sqrt(k)) * n, k >= 0);
+            double k = 1.0 - indexOfRefraction * indexOfRefraction * (1.0 - ni * ni);
+            return select(0.0f, indexOfRefraction * i - (indexOfRefraction * ni + sqrt(k)) * n, k >= 0);
         }
 
         /// <summary>
@@ -4539,12 +4539,12 @@ public static double4 refract(double4 i, double4 n, double eta)
         /// which will use a given default value if the result is not finite.
         /// </remarks>
         /// <param name="a">Vector to project.</param>
-        /// <param name="b">Non-zero vector to project onto.</param>
+        /// <param name="ontoB">Non-zero vector to project onto.</param>
         /// <returns>Vector projection of a onto b.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 project(float2 a, float2 b)
+        public static float2 project(float2 a, float2 ontoB)
         {
-            return (dot(a, b) / dot(b, b)) * b;
+            return (dot(a, ontoB) / dot(ontoB, ontoB)) * ontoB;
         }
 
         /// <summary>
@@ -4557,12 +4557,12 @@ public static float2 project(float2 a, float2 b)
         /// which will use a given default value if the result is not finite.
         /// </remarks>
         /// <param name="a">Vector to project.</param>
-        /// <param name="b">Non-zero vector to project onto.</param>
+        /// <param name="ontoB">Non-zero vector to project onto.</param>
         /// <returns>Vector projection of a onto b.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 project(float3 a, float3 b)
+        public static float3 project(float3 a, float3 ontoB)
         {
-            return (dot(a, b) / dot(b, b)) * b;
+            return (dot(a, ontoB) / dot(ontoB, ontoB)) * ontoB;
         }
 
         /// <summary>
@@ -4575,12 +4575,12 @@ public static float3 project(float3 a, float3 b)
         /// which will use a given default value if the result is not finite.
         /// </remarks>
         /// <param name="a">Vector to project.</param>
-        /// <param name="b">Non-zero vector to project onto.</param>
+        /// <param name="ontoB">Non-zero vector to project onto.</param>
         /// <returns>Vector projection of a onto b.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 project(float4 a, float4 b)
+        public static float4 project(float4 a, float4 ontoB)
         {
-            return (dot(a, b) / dot(b, b)) * b;
+            return (dot(a, ontoB) / dot(ontoB, ontoB)) * ontoB;
         }
 
         /// <summary>
@@ -4593,13 +4593,13 @@ public static float4 project(float4 a, float4 b)
         /// function.
         /// </remarks>
         /// <param name="a">Vector to project.</param>
-        /// <param name="b">Non-zero vector to project onto.</param>
+        /// <param name="ontoB">Non-zero vector to project onto.</param>
         /// <param name="defaultValue">Default value to return if projection is not finite.</param>
         /// <returns>Vector projection of a onto b or the default value.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 projectsafe(float2 a, float2 b, float2 defaultValue = new float2())
+        public static float2 projectsafe(float2 a, float2 ontoB, float2 defaultValue = new float2())
         {
-            var proj = project(a, b);
+            var proj = project(a, ontoB);
 
             return select(defaultValue, proj, all(isfinite(proj)));
         }
@@ -4614,13 +4614,13 @@ public static float4 project(float4 a, float4 b)
         /// function.
         /// </remarks>
         /// <param name="a">Vector to project.</param>
-        /// <param name="b">Non-zero vector to project onto.</param>
+        /// <param name="ontoB">Non-zero vector to project onto.</param>
         /// <param name="defaultValue">Default value to return if projection is not finite.</param>
         /// <returns>Vector projection of a onto b or the default value.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 projectsafe(float3 a, float3 b, float3 defaultValue = new float3())
+        public static float3 projectsafe(float3 a, float3 ontoB, float3 defaultValue = new float3())
         {
-            var proj = project(a, b);
+            var proj = project(a, ontoB);
 
             return select(defaultValue, proj, all(isfinite(proj)));
         }
@@ -4635,13 +4635,13 @@ public static float4 project(float4 a, float4 b)
         /// function.
         /// </remarks>
         /// <param name="a">Vector to project.</param>
-        /// <param name="b">Non-zero vector to project onto.</param>
+        /// <param name="ontoB">Non-zero vector to project onto.</param>
         /// <param name="defaultValue">Default value to return if projection is not finite.</param>
         /// <returns>Vector projection of a onto b or the default value.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 projectsafe(float4 a, float4 b, float4 defaultValue = new float4())
+        public static float4 projectsafe(float4 a, float4 ontoB, float4 defaultValue = new float4())
         {
-            var proj = project(a, b);
+            var proj = project(a, ontoB);
 
             return select(defaultValue, proj, all(isfinite(proj)));
         }
@@ -4656,12 +4656,12 @@ public static float4 project(float4 a, float4 b)
         /// which will use a given default value if the result is not finite.
         /// </remarks>
         /// <param name="a">Vector to project.</param>
-        /// <param name="b">Non-zero vector to project onto.</param>
+        /// <param name="ontoB">Non-zero vector to project onto.</param>
         /// <returns>Vector projection of a onto b.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double2 project(double2 a, double2 b)
+        public static double2 project(double2 a, double2 ontoB)
         {
-            return (dot(a, b) / dot(b, b)) * b;
+            return (dot(a, ontoB) / dot(ontoB, ontoB)) * ontoB;
         }
 
         /// <summary>
@@ -4674,12 +4674,12 @@ public static double2 project(double2 a, double2 b)
         /// which will use a given default value if the result is not finite.
         /// </remarks>
         /// <param name="a">Vector to project.</param>
-        /// <param name="b">Non-zero vector to project onto.</param>
+        /// <param name="ontoB">Non-zero vector to project onto.</param>
         /// <returns>Vector projection of a onto b.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double3 project(double3 a, double3 b)
+        public static double3 project(double3 a, double3 ontoB)
         {
-            return (dot(a, b) / dot(b, b)) * b;
+            return (dot(a, ontoB) / dot(ontoB, ontoB)) * ontoB;
         }
 
         /// <summary>
@@ -4692,12 +4692,12 @@ public static double3 project(double3 a, double3 b)
         /// which will use a given default value if the result is not finite.
         /// </remarks>
         /// <param name="a">Vector to project.</param>
-        /// <param name="b">Non-zero vector to project onto.</param>
+        /// <param name="ontoB">Non-zero vector to project onto.</param>
         /// <returns>Vector projection of a onto b.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double4 project(double4 a, double4 b)
+        public static double4 project(double4 a, double4 ontoB)
         {
-            return (dot(a, b) / dot(b, b)) * b;
+            return (dot(a, ontoB) / dot(ontoB, ontoB)) * ontoB;
         }
 
         /// <summary>
@@ -4710,13 +4710,13 @@ public static double4 project(double4 a, double4 b)
         /// function.
         /// </remarks>
         /// <param name="a">Vector to project.</param>
-        /// <param name="b">Non-zero vector to project onto.</param>
+        /// <param name="ontoB">Non-zero vector to project onto.</param>
         /// <param name="defaultValue">Default value to return if projection is not finite.</param>
         /// <returns>Vector projection of a onto b or the default value.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double2 projectsafe(double2 a, double2 b, double2 defaultValue = new double2())
+        public static double2 projectsafe(double2 a, double2 ontoB, double2 defaultValue = new double2())
         {
-            var proj = project(a, b);
+            var proj = project(a, ontoB);
 
             return select(defaultValue, proj, all(isfinite(proj)));
         }
@@ -4731,13 +4731,13 @@ public static double4 project(double4 a, double4 b)
         /// function.
         /// </remarks>
         /// <param name="a">Vector to project.</param>
-        /// <param name="b">Non-zero vector to project onto.</param>
+        /// <param name="ontoB">Non-zero vector to project onto.</param>
         /// <param name="defaultValue">Default value to return if projection is not finite.</param>
         /// <returns>Vector projection of a onto b or the default value.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double3 projectsafe(double3 a, double3 b, double3 defaultValue = new double3())
+        public static double3 projectsafe(double3 a, double3 ontoB, double3 defaultValue = new double3())
         {
-            var proj = project(a, b);
+            var proj = project(a, ontoB);
 
             return select(defaultValue, proj, all(isfinite(proj)));
         }
@@ -4752,13 +4752,13 @@ public static double4 project(double4 a, double4 b)
         /// function.
         /// </remarks>
         /// <param name="a">Vector to project.</param>
-        /// <param name="b">Non-zero vector to project onto.</param>
+        /// <param name="ontoB">Non-zero vector to project onto.</param>
         /// <param name="defaultValue">Default value to return if projection is not finite.</param>
         /// <returns>Vector projection of a onto b or the default value.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double4 projectsafe(double4 a, double4 b, double4 defaultValue = new double4())
+        public static double4 projectsafe(double4 a, double4 ontoB, double4 defaultValue = new double4())
         {
-            var proj = project(a, b);
+            var proj = project(a, ontoB);
 
             return select(defaultValue, proj, all(isfinite(proj)));
         }

From 835c605ad7cea3fd26472773989cbe962111ba0b Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Thu, 10 Feb 2022 11:45:37 -0800
Subject: [PATCH 45/94] Added more math constants such as PI2, PIHALF, TAU and
 others. (#217)

* Added more math constants such as PI2, PIHALF, TAU and others.

* Update changelog.

* Make math.degrees and math.radians use new constants.
---
 src/CHANGELOG.md                   |  1 +
 src/Tests/Tests/Shared/TestMath.cs | 74 +++++++++++++++++++++++++
 src/Unity.Mathematics/math.cs      | 86 ++++++++++++++++++++++++------
 3 files changed, 145 insertions(+), 16 deletions(-)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index d744d474..8715ada6 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -12,6 +12,7 @@
 * Added `math.mulScale` to scale columns of a float3x3 with scaling coefficients in a float3.
 * Added `math.scaleMul` to scale rows of a float3x3 with scaling coefficients in a float3.
 * Added `AffineTransform` type.
+* Added `PI2`, `PIHALF`, `TAU`, `TODEGREES` and `TORADIANS` constants.
 ### Changed
 * `asfloat(uint)`, `asuint(float)`, `asint(float)` and other related methods are now faster in mono without Burst. Other methods which use these will see a performance improvement.
 * Modified `quaternion.nlerp` to be branchless.
diff --git a/src/Tests/Tests/Shared/TestMath.cs b/src/Tests/Tests/Shared/TestMath.cs
index 7691c5d3..d22d82a7 100644
--- a/src/Tests/Tests/Shared/TestMath.cs
+++ b/src/Tests/Tests/Shared/TestMath.cs
@@ -4122,5 +4122,79 @@ public static void scaleMul()
 
             TestUtils.AreEqual(expected, actual, tolerance);
         }
+
+        [TestCompiler]
+        public static void piDoubleConstants()
+        {
+            var expectedPi = 3.141592653589793116;
+            TestUtils.AreEqual(expectedPi, PI_DBL);
+            TestUtils.AreEqual(expectedPi * 0.5, PIHALF_DBL);
+            TestUtils.AreEqual(expectedPi * 2.0, PI2_DBL);
+            TestUtils.AreEqual(expectedPi * 2.0, TAU_DBL);
+        }
+
+        [TestCompiler]
+        public static void piSingleConstants()
+        {
+            var expectedPi = 3.141592653589793116f;
+            TestUtils.AreEqual(expectedPi, PI);
+            TestUtils.AreEqual(expectedPi * 0.5f, PIHALF);
+            TestUtils.AreEqual(expectedPi * 2.0f, PI2);
+            TestUtils.AreEqual(expectedPi * 2.0f, TAU);
+        }
+
+        [TestCompiler]
+        public static void toDegreesConstants()
+        {
+            TestUtils.AreEqual(360.0, PI2_DBL * TODEGREES_DBL);
+            TestUtils.AreEqual(360.0, TAU_DBL * TODEGREES_DBL);
+            TestUtils.AreEqual(180.0, PI_DBL * TODEGREES_DBL);
+            TestUtils.AreEqual(90.0, PIHALF_DBL * TODEGREES_DBL);
+
+            TestUtils.AreEqual(360.0f, PI2 * TODEGREES);
+            TestUtils.AreEqual(360.0f, TAU * TODEGREES);
+            TestUtils.AreEqual(180.0f, PI * TODEGREES);
+            TestUtils.AreEqual(90.0f, PIHALF * TODEGREES);
+        }
+
+        [TestCompiler]
+        public static void toRadiansConstants()
+        {
+            TestUtils.AreEqual(PI2_DBL, 360.0 * TORADIANS_DBL);
+            TestUtils.AreEqual(TAU_DBL, 360.0 * TORADIANS_DBL);
+            TestUtils.AreEqual(PI_DBL, 180.0 * TORADIANS_DBL);
+            TestUtils.AreEqual(PIHALF_DBL, 90.0 * TORADIANS_DBL);
+
+            TestUtils.AreEqual(PI2, 360.0f * TORADIANS);
+            TestUtils.AreEqual(TAU, 360.0f * TORADIANS);
+            TestUtils.AreEqual(PI, 180.0f * TORADIANS);
+            TestUtils.AreEqual(PIHALF, 90.0f * TORADIANS);
+        }
+
+        [TestCompiler]
+        public static void degreesConversionGivesSameResult()
+        {
+            int n = 360;
+
+            for (int i = 0; i <= n; ++i)
+            {
+                double radians = math.unlerp((double)0, (double)n, (double)i) * PI_DBL;
+                TestUtils.AreEqual(math.degrees(radians), radians * TODEGREES_DBL);
+                TestUtils.AreEqual(math.degrees((float)radians), (float)radians * TODEGREES);
+            }
+        }
+
+        [TestCompiler]
+        public static void radiansConversionGivesSameResult()
+        {
+            int n = 360;
+
+            for (int i = 0; i <= n; ++i)
+            {
+                double degrees = (double)i;
+                TestUtils.AreEqual(math.radians(degrees), degrees * TORADIANS_DBL);
+                TestUtils.AreEqual(math.radians((float)degrees), (float)degrees * TORADIANS);
+            }
+        }
     }
 }
diff --git a/src/Unity.Mathematics/math.cs b/src/Unity.Mathematics/math.cs
index 73204610..f2ef33b7 100644
--- a/src/Unity.Mathematics/math.cs
+++ b/src/Unity.Mathematics/math.cs
@@ -70,6 +70,33 @@ public enum ShuffleComponent : byte
         /// <summary>The mathematical constant pi. Approximately 3.14. This is a f64/double precision constant.</summary>
         public const double PI_DBL = 3.14159265358979323846;
 
+        /// <summary>
+        /// The mathematical constant (2 * pi). Approximately 6.28. This is a f64/double precision constant. Also known as <see cref="TAU_DBL"/>.
+        /// </summary>
+        public const double PI2_DBL = PI_DBL * 2.0;
+
+        /// <summary>
+        /// The mathematical constant (pi / 2). Approximately 1.57. This is a f64/double precision constant.
+        /// </summary>
+        public const double PIHALF_DBL = PI_DBL * 0.5;
+
+        /// <summary>
+        /// The mathematical constant tau. Approximately 6.28. This is a f64/double precision constant. Also known as <see cref="PI2_DBL"/>.
+        /// </summary>
+        public const double TAU_DBL = PI2_DBL;
+
+        /// <summary>
+        /// The conversion constant used to convert radians to degrees. Multiply the radian value by this constant to get degrees.
+        /// </summary>
+        /// <remarks>Multiplying by this constant is equivalent to using <see cref="math.degrees(double)"/>.</remarks>
+        public const double TODEGREES_DBL = 57.29577951308232;
+
+        /// <summary>
+        /// The conversion constant used to convert degrees to radians. Multiply the degree value by this constant to get radians.
+        /// </summary>
+        /// <remarks>Multiplying by this constant is equivalent to using <see cref="math.radians(double)"/>.</remarks>
+        public const double TORADIANS_DBL = 0.017453292519943296;
+
         /// <summary>The square root 2. Approximately 1.41. This is a f64/double precision constant.</summary>
         public const double SQRT2_DBL = 1.41421356237309504880;
 
@@ -121,6 +148,33 @@ public enum ShuffleComponent : byte
         /// <summary>The mathematical constant pi. Approximately 3.14.</summary>
         public const float PI = (float)PI_DBL;
 
+        /// <summary>
+        /// The mathematical constant (2 * pi). Approximately 6.28. Also known as <see cref="TAU"/>.
+        /// </summary>
+        public const float PI2 = (float)PI2_DBL;
+
+        /// <summary>
+        /// The mathematical constant (pi / 2). Approximately 1.57.
+        /// </summary>
+        public const float PIHALF = (float)PIHALF_DBL;
+
+        /// <summary>
+        /// The mathematical constant tau. Approximately 6.28. Also known as <see cref="PI2"/>.
+        /// </summary>
+        public const float TAU = (float)PI2_DBL;
+
+        /// <summary>
+        /// The conversion constant used to convert radians to degrees. Multiply the radian value by this constant to get degrees.
+        /// </summary>
+        /// <remarks>Multiplying by this constant is equivalent to using <see cref="math.degrees(float)"/>.</remarks>
+        public const float TODEGREES = (float)TODEGREES_DBL;
+
+        /// <summary>
+        /// The conversion constant used to convert degrees to radians. Multiply the degree value by this constant to get radians.
+        /// </summary>
+        /// <remarks>Multiplying by this constant is equivalent to using <see cref="math.radians(float)"/>.</remarks>
+        public const float TORADIANS = (float)TORADIANS_DBL;
+
         /// <summary>The square root 2. Approximately 1.41.</summary>
         public const float SQRT2 = (float)SQRT2_DBL;
 
@@ -5826,100 +5880,100 @@ public static int4 floorlog2(uint4 x)
         /// <param name="x">Angle in degrees.</param>
         /// <returns>Angle converted to radians.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float radians(float x) { return x * 0.0174532925f; }
+        public static float radians(float x) { return x * TORADIANS; }
 
         /// <summary>Returns the result of a componentwise conversion of a float2 vector from degrees to radians.</summary>
         /// <param name="x">Vector containing angles in degrees.</param>
         /// <returns>Vector containing angles converted to radians.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 radians(float2 x) { return x * 0.0174532925f; }
+        public static float2 radians(float2 x) { return x * TORADIANS; }
 
         /// <summary>Returns the result of a componentwise conversion of a float3 vector from degrees to radians.</summary>
         /// <param name="x">Vector containing angles in degrees.</param>
         /// <returns>Vector containing angles converted to radians.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 radians(float3 x) { return x * 0.0174532925f; }
+        public static float3 radians(float3 x) { return x * TORADIANS; }
 
         /// <summary>Returns the result of a componentwise conversion of a float4 vector from degrees to radians.</summary>
         /// <param name="x">Vector containing angles in degrees.</param>
         /// <returns>Vector containing angles converted to radians.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 radians(float4 x) { return x * 0.0174532925f; }
+        public static float4 radians(float4 x) { return x * TORADIANS; }
 
 
         /// <summary>Returns the result of converting a float value from degrees to radians.</summary>
         /// <param name="x">Angle in degrees.</param>
         /// <returns>Angle converted to radians.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double radians(double x) { return x * 0.017453292519943296; }
+        public static double radians(double x) { return x * TORADIANS_DBL; }
 
         /// <summary>Returns the result of a componentwise conversion of a float2 vector from degrees to radians.</summary>
         /// <param name="x">Vector containing angles in degrees.</param>
         /// <returns>Vector containing angles converted to radians.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double2 radians(double2 x) { return x * 0.017453292519943296; }
+        public static double2 radians(double2 x) { return x * TORADIANS_DBL; }
 
         /// <summary>Returns the result of a componentwise conversion of a float3 vector from degrees to radians.</summary>
         /// <param name="x">Vector containing angles in degrees.</param>
         /// <returns>Vector containing angles converted to radians.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double3 radians(double3 x) { return x * 0.017453292519943296; }
+        public static double3 radians(double3 x) { return x * TORADIANS_DBL; }
 
         /// <summary>Returns the result of a componentwise conversion of a float4 vector from degrees to radians.</summary>
         /// <param name="x">Vector containing angles in degrees.</param>
         /// <returns>Vector containing angles converted to radians.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double4 radians(double4 x) { return x * 0.017453292519943296; }
+        public static double4 radians(double4 x) { return x * TORADIANS_DBL; }
 
 
         /// <summary>Returns the result of converting a double value from radians to degrees.</summary>
         /// <param name="x">Angle in radians.</param>
         /// <returns>Angle converted to degrees.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float degrees(float x) { return x * 57.295779513f; }
+        public static float degrees(float x) { return x * TODEGREES; }
 
         /// <summary>Returns the result of a componentwise conversion of a double2 vector from radians to degrees.</summary>
         /// <param name="x">Vector containing angles in radians.</param>
         /// <returns>Vector containing angles converted to degrees.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float2 degrees(float2 x) { return x * 57.295779513f; }
+        public static float2 degrees(float2 x) { return x * TODEGREES; }
 
         /// <summary>Returns the result of a componentwise conversion of a double3 vector from radians to degrees.</summary>
         /// <param name="x">Vector containing angles in radians.</param>
         /// <returns>Vector containing angles converted to degrees.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float3 degrees(float3 x) { return x * 57.295779513f; }
+        public static float3 degrees(float3 x) { return x * TODEGREES; }
 
         /// <summary>Returns the result of a componentwise conversion of a double4 vector from radians to degrees.</summary>
         /// <param name="x">Vector containing angles in radians.</param>
         /// <returns>Vector containing angles converted to degrees.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float4 degrees(float4 x) { return x * 57.295779513f; }
+        public static float4 degrees(float4 x) { return x * TODEGREES; }
 
 
         /// <summary>Returns the result of converting a double value from radians to degrees.</summary>
         /// <param name="x">Angle in radians.</param>
         /// <returns>Angle converted to degrees.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double degrees(double x) { return x * 57.29577951308232; }
+        public static double degrees(double x) { return x * TODEGREES_DBL; }
 
         /// <summary>Returns the result of a componentwise conversion of a double2 vector from radians to degrees.</summary>
         /// <param name="x">Vector containing angles in radians.</param>
         /// <returns>Vector containing angles converted to degrees.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double2 degrees(double2 x) { return x * 57.29577951308232; }
+        public static double2 degrees(double2 x) { return x * TODEGREES_DBL; }
 
         /// <summary>Returns the result of a componentwise conversion of a double3 vector from radians to degrees.</summary>
         /// <param name="x">Vector containing angles in radians.</param>
         /// <returns>Vector containing values converted to degrees.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double3 degrees(double3 x) { return x * 57.29577951308232; }
+        public static double3 degrees(double3 x) { return x * TODEGREES_DBL; }
 
         /// <summary>Returns the result of a componentwise conversion of a double4 vector from radians to degrees.</summary>
         /// <param name="x">Vector containing angles in radians.</param>
         /// <returns>Vector containing angles converted to degrees.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static double4 degrees(double4 x) { return x * 57.29577951308232; }
+        public static double4 degrees(double4 x) { return x * TODEGREES_DBL; }
 
 
         /// <summary>Returns the minimum component of an int2 vector.</summary>

From 4f7944a5f08ad1b8d0a879885c0e72acbd45226f Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Thu, 10 Feb 2022 17:43:59 -0800
Subject: [PATCH 46/94] Make Il2CppEagerStaticClassConstructionAttribute
 internal. (#214)

Having this attribute public made it possible to conflict with
defnitions made elsewhere. Hiding it as internal will avoid the
possibility of our definition conflicting with another.
---
 src/CHANGELOG.md                                                | 1 +
 .../Il2CppEagerStaticClassConstructionAttribute.cs              | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index 8715ada6..7e856def 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -17,6 +17,7 @@
 * `asfloat(uint)`, `asuint(float)`, `asint(float)` and other related methods are now faster in mono without Burst. Other methods which use these will see a performance improvement.
 * Modified `quaternion.nlerp` to be branchless.
 * More descriptive parameter names for many methods in `math` class.
+* Made `Il2CppEagerStaticClassConstructionAttribute` internal to avoid conflicts with other definitions outside of the package.
 ### Deprecated
 ### Removed
 ### Fixed
diff --git a/src/Unity.Mathematics/Il2CppEagerStaticClassConstructionAttribute.cs b/src/Unity.Mathematics/Il2CppEagerStaticClassConstructionAttribute.cs
index 1588a77e..6f64b476 100644
--- a/src/Unity.Mathematics/Il2CppEagerStaticClassConstructionAttribute.cs
+++ b/src/Unity.Mathematics/Il2CppEagerStaticClassConstructionAttribute.cs
@@ -7,7 +7,7 @@ namespace Unity.IL2CPP.CompilerServices
     /// rather than lazily at runtime.
     /// </summary>
     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = false, AllowMultiple = false)]
-    public class Il2CppEagerStaticClassConstructionAttribute : Attribute
+    internal class Il2CppEagerStaticClassConstructionAttribute : Attribute
     {
     }
 }
\ No newline at end of file

From f476dc88954697f71e5615b5f57462495bc973a7 Mon Sep 17 00:00:00 2001
From: kevinmv <45053404+kevinmv@users.noreply.github.com>
Date: Mon, 14 Feb 2022 16:59:49 -0500
Subject: [PATCH 47/94] Warning fix for Unity.Mathematics.CodeGen scripts
 (#218)

* Move CodeGen dir to an editor ignored directory. The editor will warn that we won't load the scripts in the dir as there is no asmdef ro the files (nor do we want one)

* Delete unused Assets/Tests dir and assembly.

* Preemptively deleting shaders while I wait for RM confirmation.

This file was not meaningfully implemented and has not been shipped
with the package tarballs.

Co-authored-by: Dale Kim <3121968+unpacklo@users.noreply.github.com>
---
 .gitignore                                    |   1 +
 .../Assets/Tests.meta                         |   8 -
 .../Assets/Tests/Tests.asmdef                 |   6 -
 .../Assets/Tests/Tests.asmdef.meta            |   7 -
 src/.npmignore                                |   1 -
 src/Unity.Mathematics.CodeGen.meta            |   8 -
 .../Program.cs                                |   0
 .../Program.cs.meta                           |   0
 .../Properties.meta                           |   0
 .../Properties/AssemblyInfo.cs                |   0
 .../Properties/AssemblyInfo.cs.meta           |   0
 .../Unity.Mathematics.CodeGen.csproj          |   0
 .../VectorGenerator.cs                        |   0
 .../VectorGenerator.cs.meta                   |   0
 src/Unity.Mathematics.Shaders.meta            |   8 -
 src/Unity.Mathematics.Shaders/hlsl.cs         | 142 ------------------
 src/Unity.Mathematics.Shaders/hlsl.cs.meta    |  11 --
 17 files changed, 1 insertion(+), 191 deletions(-)
 delete mode 100644 Unity.Mathematics.TestProject/Assets/Tests.meta
 delete mode 100644 Unity.Mathematics.TestProject/Assets/Tests/Tests.asmdef
 delete mode 100644 Unity.Mathematics.TestProject/Assets/Tests/Tests.asmdef.meta
 delete mode 100644 src/Unity.Mathematics.CodeGen.meta
 rename src/{Unity.Mathematics.CodeGen => Unity.Mathematics.CodeGen~}/Program.cs (100%)
 rename src/{Unity.Mathematics.CodeGen => Unity.Mathematics.CodeGen~}/Program.cs.meta (100%)
 rename src/{Unity.Mathematics.CodeGen => Unity.Mathematics.CodeGen~}/Properties.meta (100%)
 rename src/{Unity.Mathematics.CodeGen => Unity.Mathematics.CodeGen~}/Properties/AssemblyInfo.cs (100%)
 rename src/{Unity.Mathematics.CodeGen => Unity.Mathematics.CodeGen~}/Properties/AssemblyInfo.cs.meta (100%)
 rename src/{Unity.Mathematics.CodeGen => Unity.Mathematics.CodeGen~}/Unity.Mathematics.CodeGen.csproj (100%)
 rename src/{Unity.Mathematics.CodeGen => Unity.Mathematics.CodeGen~}/VectorGenerator.cs (100%)
 rename src/{Unity.Mathematics.CodeGen => Unity.Mathematics.CodeGen~}/VectorGenerator.cs.meta (100%)
 delete mode 100644 src/Unity.Mathematics.Shaders.meta
 delete mode 100644 src/Unity.Mathematics.Shaders/hlsl.cs
 delete mode 100644 src/Unity.Mathematics.Shaders/hlsl.cs.meta

diff --git a/.gitignore b/.gitignore
index 9efb5f82..f2d2f5bb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -177,6 +177,7 @@ ClientBin/
 [Ss]tyle[Cc]op.*
 ~$*
 *~
+!*CodeGen~
 *.dbmdl
 *.dbproj.schemaview
 *.pfx
diff --git a/Unity.Mathematics.TestProject/Assets/Tests.meta b/Unity.Mathematics.TestProject/Assets/Tests.meta
deleted file mode 100644
index 9f5f1a30..00000000
--- a/Unity.Mathematics.TestProject/Assets/Tests.meta
+++ /dev/null
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 6ea92fda216cb44a1b5e2bf49e9ef2ad
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/Unity.Mathematics.TestProject/Assets/Tests/Tests.asmdef b/Unity.Mathematics.TestProject/Assets/Tests/Tests.asmdef
deleted file mode 100644
index 45bb135b..00000000
--- a/Unity.Mathematics.TestProject/Assets/Tests/Tests.asmdef
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-    "name": "Tests",
-    "optionalUnityReferences": [
-        "TestAssemblies"
-    ]
-}
diff --git a/Unity.Mathematics.TestProject/Assets/Tests/Tests.asmdef.meta b/Unity.Mathematics.TestProject/Assets/Tests/Tests.asmdef.meta
deleted file mode 100644
index cf7cb66a..00000000
--- a/Unity.Mathematics.TestProject/Assets/Tests/Tests.asmdef.meta
+++ /dev/null
@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: 5f5c2087bc52f4f7c8326e51ec5a628d
-AssemblyDefinitionImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/src/.npmignore b/src/.npmignore
index 72855d0d..e2e54865 100755
--- a/src/.npmignore
+++ b/src/.npmignore
@@ -10,7 +10,6 @@ QAReport.md
 QAReport.md.meta
 Unity.Mathematics.CodeGen*
 Unity.Mathematics.PerformanceTests*
-Unity.Mathematics.Shaders*
 *.sln*
 *.db*
 **/*.csproj*
diff --git a/src/Unity.Mathematics.CodeGen.meta b/src/Unity.Mathematics.CodeGen.meta
deleted file mode 100644
index 192a75dc..00000000
--- a/src/Unity.Mathematics.CodeGen.meta
+++ /dev/null
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: ba9313d729590a14dbcd58e38024613d
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/src/Unity.Mathematics.CodeGen/Program.cs b/src/Unity.Mathematics.CodeGen~/Program.cs
similarity index 100%
rename from src/Unity.Mathematics.CodeGen/Program.cs
rename to src/Unity.Mathematics.CodeGen~/Program.cs
diff --git a/src/Unity.Mathematics.CodeGen/Program.cs.meta b/src/Unity.Mathematics.CodeGen~/Program.cs.meta
similarity index 100%
rename from src/Unity.Mathematics.CodeGen/Program.cs.meta
rename to src/Unity.Mathematics.CodeGen~/Program.cs.meta
diff --git a/src/Unity.Mathematics.CodeGen/Properties.meta b/src/Unity.Mathematics.CodeGen~/Properties.meta
similarity index 100%
rename from src/Unity.Mathematics.CodeGen/Properties.meta
rename to src/Unity.Mathematics.CodeGen~/Properties.meta
diff --git a/src/Unity.Mathematics.CodeGen/Properties/AssemblyInfo.cs b/src/Unity.Mathematics.CodeGen~/Properties/AssemblyInfo.cs
similarity index 100%
rename from src/Unity.Mathematics.CodeGen/Properties/AssemblyInfo.cs
rename to src/Unity.Mathematics.CodeGen~/Properties/AssemblyInfo.cs
diff --git a/src/Unity.Mathematics.CodeGen/Properties/AssemblyInfo.cs.meta b/src/Unity.Mathematics.CodeGen~/Properties/AssemblyInfo.cs.meta
similarity index 100%
rename from src/Unity.Mathematics.CodeGen/Properties/AssemblyInfo.cs.meta
rename to src/Unity.Mathematics.CodeGen~/Properties/AssemblyInfo.cs.meta
diff --git a/src/Unity.Mathematics.CodeGen/Unity.Mathematics.CodeGen.csproj b/src/Unity.Mathematics.CodeGen~/Unity.Mathematics.CodeGen.csproj
similarity index 100%
rename from src/Unity.Mathematics.CodeGen/Unity.Mathematics.CodeGen.csproj
rename to src/Unity.Mathematics.CodeGen~/Unity.Mathematics.CodeGen.csproj
diff --git a/src/Unity.Mathematics.CodeGen/VectorGenerator.cs b/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs
similarity index 100%
rename from src/Unity.Mathematics.CodeGen/VectorGenerator.cs
rename to src/Unity.Mathematics.CodeGen~/VectorGenerator.cs
diff --git a/src/Unity.Mathematics.CodeGen/VectorGenerator.cs.meta b/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs.meta
similarity index 100%
rename from src/Unity.Mathematics.CodeGen/VectorGenerator.cs.meta
rename to src/Unity.Mathematics.CodeGen~/VectorGenerator.cs.meta
diff --git a/src/Unity.Mathematics.Shaders.meta b/src/Unity.Mathematics.Shaders.meta
deleted file mode 100644
index 85226af8..00000000
--- a/src/Unity.Mathematics.Shaders.meta
+++ /dev/null
@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 9b10a64aa490dfe46a4bdee58b85da27
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/src/Unity.Mathematics.Shaders/hlsl.cs b/src/Unity.Mathematics.Shaders/hlsl.cs
deleted file mode 100644
index c49ad5e8..00000000
--- a/src/Unity.Mathematics.Shaders/hlsl.cs
+++ /dev/null
@@ -1,142 +0,0 @@
-using System.Runtime.CompilerServices;
-
-namespace Unity.Mathematics.Shaders
-{
-    public static class hlsl
-    {
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float ddx(float x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float2 ddx(float2 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float3 ddx(float3 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float4 ddx(float4 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float2x2 ddx(float2x2 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float3x3 ddx(float3x3 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float4x4 ddx(float4x4 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float ddx_fine(float x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float2 ddx_fine(float2 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float3 ddx_fine(float3 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float4 ddx_fine(float4 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float2x2 ddx_fine(float2x2 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float3x3 ddx_fine(float3x3 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float4x4 ddx_fine(float4x4 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float ddx_coarse(float x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float2 ddx_coarse(float2 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float3 ddx_coarse(float3 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float4 ddx_coarse(float4 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float2x2 ddx_coarse(float2x2 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float3x3 ddx_coarse(float3x3 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float4x4 ddx_coarse(float4x4 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float ddy(float x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float2 ddy(float2 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float3 ddy(float3 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float4 ddy(float4 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float2x2 ddy(float2x2 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float3x3 ddy(float3x3 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float4x4 ddy(float4x4 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float ddy_fine(float x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float2 ddy_fine(float2 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float3 ddy_fine(float3 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float4 ddy_fine(float4 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float2x2 ddy_fine(float2x2 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float3x3 ddy_fine(float3x3 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float4x4 ddy_fine(float4x4 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float ddy_coarse(float x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float2 ddy_coarse(float2 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float3 ddy_coarse(float3 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float4 ddy_coarse(float4 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float2x2 ddy_coarse(float2x2 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float3x3 ddy_coarse(float3x3 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float4x4 ddy_coarse(float4x4 x) { throw new System.NotImplementedException(); }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static void discard() { }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static void clip(float i) { }
-
-        [MethodImpl((MethodImplOptions)0x100)] // agressive inline
-        public static float3 faceforward(float3 n, float3 i, float3 ng) { return math.cross(-n, math.sign(math.dot(i, ng))); }
-    }
-}
diff --git a/src/Unity.Mathematics.Shaders/hlsl.cs.meta b/src/Unity.Mathematics.Shaders/hlsl.cs.meta
deleted file mode 100644
index 9b45b04e..00000000
--- a/src/Unity.Mathematics.Shaders/hlsl.cs.meta
+++ /dev/null
@@ -1,11 +0,0 @@
-fileFormatVersion: 2
-guid: f1451d4ccf06c1c4aa11ee0097e37220
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

From d67d79f8616c8141e6b18b692c1d1ce952681fbd Mon Sep 17 00:00:00 2001
From: Jo Petty <jo.dawes@unity3d.com>
Date: Thu, 23 Jun 2022 11:23:39 +0100
Subject: [PATCH 48/94] Renamed mathematics.md

---
 src/Documentation~/{mathematics.md => index.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename src/Documentation~/{mathematics.md => index.md} (100%)

diff --git a/src/Documentation~/mathematics.md b/src/Documentation~/index.md
similarity index 100%
rename from src/Documentation~/mathematics.md
rename to src/Documentation~/index.md

From 3f6123f3398e3bc020e21347eefbdfc4219a91ce Mon Sep 17 00:00:00 2001
From: Jo Petty <jo.dawes@unity3d.com>
Date: Thu, 23 Jun 2022 11:29:12 +0100
Subject: [PATCH 49/94] Added new docs

---
 src/Documentation~/4x4-matrices.md      | 48 ++++++++++++++
 src/Documentation~/TableOfContents.md   |  4 ++
 src/Documentation~/compatibility.md     | 15 +++++
 src/Documentation~/index.md             | 86 +++++-------------------
 src/Documentation~/mathematics.md.meta  |  7 --
 src/Documentation~/using-mathematics.md | 87 +++++++++++++++++++++++++
 6 files changed, 171 insertions(+), 76 deletions(-)
 create mode 100644 src/Documentation~/4x4-matrices.md
 create mode 100644 src/Documentation~/TableOfContents.md
 create mode 100644 src/Documentation~/compatibility.md
 delete mode 100644 src/Documentation~/mathematics.md.meta
 create mode 100644 src/Documentation~/using-mathematics.md

diff --git a/src/Documentation~/4x4-matrices.md b/src/Documentation~/4x4-matrices.md
new file mode 100644
index 00000000..05f092b8
--- /dev/null
+++ b/src/Documentation~/4x4-matrices.md
@@ -0,0 +1,48 @@
+# 4×4 matrices
+
+To create a 4×4 transformation matrix, use the constructors in [`float4x4`](xref:Unity.Mathematics.float4x4) to assign one value to all elements of the matrix, or individually set all 16 elements directly:
+
+
+```c#
+// Unity Mathematics example
+void Build4x4UnityMathematics()
+{
+   var c0 = new float4(1.0f, 0.0f, 0.0f, 0.0f);
+   var c1 = new float4(0.0f, 1.0f, 0.0f, 0.0f);
+   var c2 = new float4(0.0f, 0.0f, 1.0f, 0.0f);
+   var c3 = new float4(0.0f, 0.0f, 0.0f, 1.0f);
+   var m = new float4x4(c0, c1, c2, c3);
+}
+```
+
+## Multiplying a 4×4 matrix
+
+Unity Mathematics defines the `*` operator differently to `UnityEngine`. The `*` operator for [`float4x4`](xref:Unity.Mathematics.float4x4) implements componentwise multiplication. If you multiply a `float4x4` of all 1s with 0.5 on the diagonal, you get back the half identity because the upper and lower triangles of the matrix are multiplied by the respective zero entries from `f4x4_HalfIdentity`:
+
+```c#
+// Unity Mathematics example
+void OperatorMultiply4x4UnityMathematics()
+{
+   float4x4 result = f4x4_Ones * f4x4_HalfIdentity;
+   // result:
+   // 0.5, 0.0, 0.0, 0.0,
+   // 0.0, 0.5, 0.0, 0.0,
+   // 0.0, 0.0, 0.5, 0.0,
+   // 0.0, 0.0, 0.0, 0.5
+}
+```
+
+## Multiplying a 4×4 matrix and a 4D vector
+
+Use the [`math.mul`](xref:Unity.Mathematics.math.mul*) method to multiply a 4×4 matrix and a 4D vector. If you supply a `float4x4` as the first parameter and a `float4` as the second, it performs a 4×4 matrix multiplication with a 4×1 column vector, which returns a 4×1 column vector as a `float4`.
+
+`math.mul` can also multiply a 1×4 row vector by a 4×4 matrix to produce a 1×4  row vector by taking a `float4` as the first parameter and a `float4×4` as the second. Unity Mathematics stores the row vector in a `float4` and it isn't treated as a separate type.
+
+```c#
+// Unity Mathematics example
+void Multiply4x4AndVector4UnityMathematics()
+{
+   float4 result1 = math.mul(f4x4, f4); // 4x4 * 4x1 = 4x1
+   float4 result2 = math.mul(f4, f4x4); // 1x4 * 4x4 = 1x4
+}
+```
\ No newline at end of file
diff --git a/src/Documentation~/TableOfContents.md b/src/Documentation~/TableOfContents.md
new file mode 100644
index 00000000..2907837f
--- /dev/null
+++ b/src/Documentation~/TableOfContents.md
@@ -0,0 +1,4 @@
+* [Unity Mathematics](index.md)
+* [Compatibility with Mathf](compatibility.md)
+* [Using Unity Mathematics](using-mathematics.md)
+    * [4×4 matrices](4x4-matrices.md)
diff --git a/src/Documentation~/compatibility.md b/src/Documentation~/compatibility.md
new file mode 100644
index 00000000..94d6f17c
--- /dev/null
+++ b/src/Documentation~/compatibility.md
@@ -0,0 +1,15 @@
+# Compatibility with `Mathf`
+
+Unity Mathematics isn't implemented in the same way as the [`UnityEngine.Mathf`](https://docs.unity3d.com/ScriptReference/Mathf.html) struct in the core Unity engine. Because of this, if your application relies on the specific behaviors of `Mathf`, it might not be possible to use Unity Mathematics in your project. Also, if your project uses `Mathf` functions that have no corresponding Unity Mathematics function, or your code uses external plug-ins that depend on Unity types such as `Vector3`, or `Matrix4x4`, then you shouldn't use Unity Mathematics.
+
+>[!IMPORTANT]
+>For performance reasons, if your project uses the Mono compiler, you should continue to use the mathematical operations in `Mathf`, rather than Unity Mathematics.
+
+## Porting `Mathf` code to Unity Mathematics
+
+If you want to migrate code from `UnityEngine` to `Unity.Mathematics`, you need to make the following changes first:
+
+* `Vector4` to `float4`
+* Multiplications on vector or matrix objects to component multiplication with the `*` operator.
+* Degrees to radians
+* How your code generates random numbers
\ No newline at end of file
diff --git a/src/Documentation~/index.md b/src/Documentation~/index.md
index 992642fc..f158d0db 100644
--- a/src/Documentation~/index.md
+++ b/src/Documentation~/index.md
@@ -1,79 +1,27 @@
-# Unity.Mathematics
+# Unity Mathematics
 
-A C# math library providing vector types and math functions with a shader like
-syntax. Used by the Burst compiler to compile C#/IL to highly efficient
-native code.
+Unity Mathematics is a C# math library that provides vector types and math functions that have a shader-like
+syntax, similar to [SIMD](https://en.wikipedia.org/wiki/Single_instruction,_multiple_data) or [HLSL](https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl). The [Burst compiler](https://docs.unity3d.com/Packages/com.unity.burst@latest) uses Unity Mathematics to compile C#/IL code into highly efficient native code.
 
-The main goal of this library is to provide a friendly Math API familiar to SIMD and graphic/shaders developers, using the well known `float4`, `float3` types...etc. with all intrinsics functions provided by a static class `math` that can be imported easily into your C# program with `using static Unity.Mathematics.math`.
+It implements the following vector and matrix types:
 
-In addition to this, the Burst compiler is able to recognize these types and provide the optimized SIMD type for the running CPU on all supported platforms (x64, ARMv7a...etc.)
+* floatN, quaternion
+* float3×3, float4×4
 
-NOTICE: The API is a work in progress and we may introduce breaking changes (API and underlying behavior)
+Plus elementary functions:
+* min, max, fabs, etc.
+* sin, cos, sqrt, normalize, dot, cross, etc.
 
-## Usage
+## Installation
 
-You can use this library in your Unity game by using the Package Manager and referencing the package `com.unity.mathematics`. See the forum [Welcome](https://forum.unity.com/threads/welcome.522627) page for more details.
+You can install the Mathematics package through Unity's Package Manager. For more information, see the Unity User Manual documentation on [Adding and removing packages](https://docs.unity3d.com/Manual/upm-ui-actions.html).
 
-```C#
-using static Unity.Mathematics.math;
-namespace MyNamespace
-{
-    using Unity.Mathematics;
-    
-    ...
-    var v1 = float3(1,2,3);
-    var v2 = float3(4,5,6);
-    v1 = normalize(v1);
-    v2 = normalize(v2);
-    var v3 = dot(v1, v2);
-    ...
-}
-```
+### Editor config
 
-## Building
+Unity Mathematics uses [editorconfig](http://editorconfig.org/) to keep files formatted for EOL and spaces.
 
-Open the `src\Unity.Mathematics.sln` under Visual Studio 2015 or MonoDevelop and compile in Debug\Release.
-
-## Contributing
-
-We don't yet accept PR on this repository. See the FAQ below.
-
-The project is using [editorconfig](http://editorconfig.org/) to keep files correctly formatted for EOL and spaces.
-
-We assume that your IDE has support for `editorconfig`, you can download the following extensions if your IDE is listed:
-
-- [VS2015/VS2017 EditorConfig extension](https://marketplace.visualstudio.com/items?itemName=EditorConfigTeam.EditorConfig)
-- [Visual Studio Code EditorConfig extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig)
-- [SublimeText EditorConfig extension](https://github.com/sindresorhus/editorconfig-sublime)
-
-## Frequently Asked Question
-
-### Why developing another Math library instead of using existing Unity Vector3...etc.?
-
-After years of feedback and experience with the previous API, we believe that providing an API that is closer to the way graphics developers have been using math libraries should better help its adoption and the ease of its usage. HLSL / GLSL math library is a very well designed, well understood math library leading to greater consistency.
-
-### Why not using `System.Numerics.Vectors`?
-
-Mainly for the reason mentioned above, `System.Numerics.Vectors` is in many ways similar to our previous Vector library (more object oriented than graphics programming oriented).
-Also the fact that our Burst compiler is able to recognize a lot more patterns for SIMD types and math intrinsics makes it easier to work with a dedicated API that reflects this ability.
-
-### Naming convention
-
-In C# `int` and `float` are considered builtin types. Burst extends this set of bultin types to also include vectors, matrices and quaternions. These types are bultin in the sense that Burst knows about them and is be able to generate better code using these types than what would be possible with equivalent code using custom types.
-
-To signify that these types are bultin their type names are in all lower case. The operators on these bultin types found in `Unity.Mathematics.math` are considered intrinsics and are thus always in lower case.
-
-There are no plans to extend the set of intrinsic types beyond the current set of vectors (`typeN`), matrices (`typeNxN`) and quaternions (`quaternion`).
-
-This convention has the added benefit of making the library highly compatible with shader code and makes porting or sharing code between the two almost frictionless.
-
-### Why can't we send a PR yet?
-
-We are working on providing a Contributor License Agreement (CLA) with a sign-over functionality and our UCL License doesn't cover this yet.
-
-## Licensing
-
-Unity Companion License (“License”) Software Copyright © 2019 Unity Technologies ApS
-
-For licensing details see [LICENSE.md](LICENSE.md)
+Your IDE should have support for `editorconfig`. If it doesn't, you can get the extension for it here: 
 
+* [VS2015/VS2017 EditorConfig extension](https://marketplace.visualstudio.com/items?itemName=EditorConfigTeam.EditorConfig)
+* [Visual Studio Code EditorConfig extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig)
+* [SublimeText EditorConfig extension](https://github.com/sindresorhus/editorconfig-sublime)
diff --git a/src/Documentation~/mathematics.md.meta b/src/Documentation~/mathematics.md.meta
deleted file mode 100644
index 10f22f41..00000000
--- a/src/Documentation~/mathematics.md.meta
+++ /dev/null
@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: d177df5c52517492b85d4191425323a9
-TextScriptImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
diff --git a/src/Documentation~/using-mathematics.md b/src/Documentation~/using-mathematics.md
new file mode 100644
index 00000000..9637b93b
--- /dev/null
+++ b/src/Documentation~/using-mathematics.md
@@ -0,0 +1,87 @@
+# Using Unity Mathematics
+
+To use Unity Mathematics, add `using Unity.Mathematics` to your code:
+
+```C#
+using static Unity.Mathematics.math;
+namespace MyNamespace
+{
+    using Unity.Mathematics;
+    
+    ...
+    var v1 = float3(1,2,3);
+    var v2 = float3(4,5,6);
+    v1 = normalize(v1);
+    v2 = normalize(v2);
+    var v3 = dot(v1, v2);
+    ...
+}
+```
+
+## Naming convention
+
+In C# `int` and `float` are built-in types. The Burst compiler extends this set of built-in types to also include vectors, matrices, and quaternions. These types are built-in because the Burst compiler already has implementations of these types, and so can use them to generate better code than for custom types.
+
+To signify that these types are built-in their type names are in all lower case. The operators on these built-in types in [`Unity.Mathematics.math`](xref:Unity.Mathematics.math) are intrinsics and are always in lower case.
+
+There are no plans to extend the set of intrinsic types beyond the current set of vectors (`typeN`), matrices (`typeNxN`) and quaternions (`quaternion`).
+
+This convention has the added benefit of making the library highly compatible with shader code and makes porting or sharing code between the two almost frictionless.
+
+
+## Vector multiplication
+
+To multiply vectors, use the `*`:
+
+```c#
+// Unity Mathematics example
+void ComponentwiseVectorMultiplyUnityMathematics()
+{
+   var v0 = new float4(2.0f, 4.0f, 6.0f, 8.0f);
+   var v1 = new float4(1.0f, -1.0f, 1.0f, -1.0f);
+   var result = v0 * v1;
+   // result == new float4(2.0f, -4.0f, 6.0f, -8.0f).
+}
+```
+
+This is a common way of writing [SIMD](https://en.wikipedia.org/wiki/Single_instruction,_multiple_data) code, which applies a single instruction to multiple data elements. Other operators such as addition, subtraction, and division work in the same way.
+
+## Quaternion multiplication
+
+To rotate a quaternion, use the [`AxisAngle`](xref:Unity.Mathematics.quaternion.AxisAngle*) method. You specify the axis of rotation and the rotation around that axis, but supply the axis first and the angle second. Also, all the angles are in radians rather than degrees. `math.mul` multiplies the quaternion, just as with [matrices](4x4-matrices.md) and vectors.
+
+```c#
+// Unity Mathematics example
+void QuaternionMultiplicationUnityMathematics()
+{
+   var axis = new float3(0.0f, 1.0f, 0.0f);
+   var q = quaternion.AxisAngle(axis,math.radians(45.0f));
+   var orientation = quaternion.Euler(
+       math.radians(45.0f),
+       math.radians(90.0f),
+       math.radians(180.0f));
+   var result = math.mul(q, orientation);
+}
+```
+
+## Random numbers
+
+To generate random numbers, you must create and manage the random number generator state yourself. This means you can control the random number generator state explicitly, which is useful it you're using parallel code, or if you want to make sure that one source of random numbers is seeded differently than another source.
+
+Once you set up the state, use [`NextFloat`](xref:Unity.Mathematics.Random.NextFloat) to get random floats. By default it returns random numbers between `[0, 1]`, exclusive:
+
+```c#
+// Unity Mathematics example
+void RandomNumberUnityMathematics()
+{
+   // Choose some non-zero seed and set up the random number generator state.
+   uint seed = 1;
+   Unity.Mathematics.Random rng = new Unity.Mathematics.Random(seed);
+
+   // [0, 1) exclusive
+   float randomFloat1 = rng.NextFloat();
+
+   // [-5, 5) exclusive
+   float randomFloat2 = rng.NextFloat(-5.0f, 5.0f);
+}
+```
\ No newline at end of file

From 802648501b06efab816698a21a07fdee04b9d66b Mon Sep 17 00:00:00 2001
From: Jo Petty <jo.dawes@unity3d.com>
Date: Thu, 23 Jun 2022 12:33:07 +0100
Subject: [PATCH 50/94] Reorganised a few pgs

---
 src/Documentation~/TableOfContents.md         |  6 +-
 src/Documentation~/getting-started.md         | 29 +++++++
 .../quaternion-multiplication.md              | 17 ++++
 src/Documentation~/random-numbers.md          | 21 +++++
 src/Documentation~/using-mathematics.md       | 87 -------------------
 src/Documentation~/vector-multiplication.md   | 16 ++++
 6 files changed, 88 insertions(+), 88 deletions(-)
 create mode 100644 src/Documentation~/getting-started.md
 create mode 100644 src/Documentation~/quaternion-multiplication.md
 create mode 100644 src/Documentation~/random-numbers.md
 delete mode 100644 src/Documentation~/using-mathematics.md
 create mode 100644 src/Documentation~/vector-multiplication.md

diff --git a/src/Documentation~/TableOfContents.md b/src/Documentation~/TableOfContents.md
index 2907837f..1dc7d3b2 100644
--- a/src/Documentation~/TableOfContents.md
+++ b/src/Documentation~/TableOfContents.md
@@ -1,4 +1,8 @@
 * [Unity Mathematics](index.md)
 * [Compatibility with Mathf](compatibility.md)
-* [Using Unity Mathematics](using-mathematics.md)
+* [Getting started](getting-started.md)
+* Common operations
     * [4×4 matrices](4x4-matrices.md)
+    * [Vector multiplication](vector-multiplication.md)
+    * [Quaternion multiplication](quaternion-multiplication.md)
+    * [Random numbers](random-numbers.md)
diff --git a/src/Documentation~/getting-started.md b/src/Documentation~/getting-started.md
new file mode 100644
index 00000000..7ed246e5
--- /dev/null
+++ b/src/Documentation~/getting-started.md
@@ -0,0 +1,29 @@
+# Getting started
+
+To use Unity Mathematics, add `using Unity.Mathematics` to your code:
+
+```C#
+using static Unity.Mathematics.math;
+namespace MyNamespace
+{
+    using Unity.Mathematics;
+    
+    ...
+    var v1 = float3(1,2,3);
+    var v2 = float3(4,5,6);
+    v1 = normalize(v1);
+    v2 = normalize(v2);
+    var v3 = dot(v1, v2);
+    ...
+}
+```
+
+## Naming convention
+
+In C# `int` and `float` are built-in types. The Burst compiler extends this set of built-in types to also include vectors, matrices, and quaternions. These types are built-in because the Burst compiler already has implementations of these types, and so can use them to generate better code than for custom types.
+
+To signify that these types are built-in their type names are in all lower case. The operators on these built-in types in [`Unity.Mathematics.math`](xref:Unity.Mathematics.math) are intrinsics and are always in lower case.
+
+There are no plans to extend the set of intrinsic types beyond the current set of vectors (`typeN`), matrices (`typeNxN`) and quaternions (`quaternion`).
+
+This convention has the added benefit of making the library highly compatible with shader code and makes porting or sharing code between the two almost frictionless.
diff --git a/src/Documentation~/quaternion-multiplication.md b/src/Documentation~/quaternion-multiplication.md
new file mode 100644
index 00000000..b9415b84
--- /dev/null
+++ b/src/Documentation~/quaternion-multiplication.md
@@ -0,0 +1,17 @@
+# Quaternion multiplication
+
+To rotate a quaternion, use the [`AxisAngle`](xref:Unity.Mathematics.quaternion.AxisAngle*) method. You specify the axis of rotation and the rotation around that axis, but supply the axis first and the angle second. Also, all the angles are in radians rather than degrees. `math.mul` multiplies the quaternion, just as with [matrices](4x4-matrices.md) and vectors.
+
+```c#
+// Unity Mathematics example
+void QuaternionMultiplicationUnityMathematics()
+{
+   var axis = new float3(0.0f, 1.0f, 0.0f);
+   var q = quaternion.AxisAngle(axis,math.radians(45.0f));
+   var orientation = quaternion.Euler(
+       math.radians(45.0f),
+       math.radians(90.0f),
+       math.radians(180.0f));
+   var result = math.mul(q, orientation);
+}
+```
diff --git a/src/Documentation~/random-numbers.md b/src/Documentation~/random-numbers.md
new file mode 100644
index 00000000..753108e3
--- /dev/null
+++ b/src/Documentation~/random-numbers.md
@@ -0,0 +1,21 @@
+## Random numbers
+
+To generate random numbers, you must create and manage the random number generator state yourself. This means you can control the random number generator state explicitly, which is useful it you're using parallel code, or if you want to make sure that one source of random numbers is seeded differently than another source.
+
+Once you set up the state, use [`NextFloat`](xref:Unity.Mathematics.Random.NextFloat) to get random floats. By default it returns random numbers between `[0, 1]`, exclusive:
+
+```c#
+// Unity Mathematics example
+void RandomNumberUnityMathematics()
+{
+   // Choose some non-zero seed and set up the random number generator state.
+   uint seed = 1;
+   Unity.Mathematics.Random rng = new Unity.Mathematics.Random(seed);
+
+   // [0, 1) exclusive
+   float randomFloat1 = rng.NextFloat();
+
+   // [-5, 5) exclusive
+   float randomFloat2 = rng.NextFloat(-5.0f, 5.0f);
+}
+```
\ No newline at end of file
diff --git a/src/Documentation~/using-mathematics.md b/src/Documentation~/using-mathematics.md
deleted file mode 100644
index 9637b93b..00000000
--- a/src/Documentation~/using-mathematics.md
+++ /dev/null
@@ -1,87 +0,0 @@
-# Using Unity Mathematics
-
-To use Unity Mathematics, add `using Unity.Mathematics` to your code:
-
-```C#
-using static Unity.Mathematics.math;
-namespace MyNamespace
-{
-    using Unity.Mathematics;
-    
-    ...
-    var v1 = float3(1,2,3);
-    var v2 = float3(4,5,6);
-    v1 = normalize(v1);
-    v2 = normalize(v2);
-    var v3 = dot(v1, v2);
-    ...
-}
-```
-
-## Naming convention
-
-In C# `int` and `float` are built-in types. The Burst compiler extends this set of built-in types to also include vectors, matrices, and quaternions. These types are built-in because the Burst compiler already has implementations of these types, and so can use them to generate better code than for custom types.
-
-To signify that these types are built-in their type names are in all lower case. The operators on these built-in types in [`Unity.Mathematics.math`](xref:Unity.Mathematics.math) are intrinsics and are always in lower case.
-
-There are no plans to extend the set of intrinsic types beyond the current set of vectors (`typeN`), matrices (`typeNxN`) and quaternions (`quaternion`).
-
-This convention has the added benefit of making the library highly compatible with shader code and makes porting or sharing code between the two almost frictionless.
-
-
-## Vector multiplication
-
-To multiply vectors, use the `*`:
-
-```c#
-// Unity Mathematics example
-void ComponentwiseVectorMultiplyUnityMathematics()
-{
-   var v0 = new float4(2.0f, 4.0f, 6.0f, 8.0f);
-   var v1 = new float4(1.0f, -1.0f, 1.0f, -1.0f);
-   var result = v0 * v1;
-   // result == new float4(2.0f, -4.0f, 6.0f, -8.0f).
-}
-```
-
-This is a common way of writing [SIMD](https://en.wikipedia.org/wiki/Single_instruction,_multiple_data) code, which applies a single instruction to multiple data elements. Other operators such as addition, subtraction, and division work in the same way.
-
-## Quaternion multiplication
-
-To rotate a quaternion, use the [`AxisAngle`](xref:Unity.Mathematics.quaternion.AxisAngle*) method. You specify the axis of rotation and the rotation around that axis, but supply the axis first and the angle second. Also, all the angles are in radians rather than degrees. `math.mul` multiplies the quaternion, just as with [matrices](4x4-matrices.md) and vectors.
-
-```c#
-// Unity Mathematics example
-void QuaternionMultiplicationUnityMathematics()
-{
-   var axis = new float3(0.0f, 1.0f, 0.0f);
-   var q = quaternion.AxisAngle(axis,math.radians(45.0f));
-   var orientation = quaternion.Euler(
-       math.radians(45.0f),
-       math.radians(90.0f),
-       math.radians(180.0f));
-   var result = math.mul(q, orientation);
-}
-```
-
-## Random numbers
-
-To generate random numbers, you must create and manage the random number generator state yourself. This means you can control the random number generator state explicitly, which is useful it you're using parallel code, or if you want to make sure that one source of random numbers is seeded differently than another source.
-
-Once you set up the state, use [`NextFloat`](xref:Unity.Mathematics.Random.NextFloat) to get random floats. By default it returns random numbers between `[0, 1]`, exclusive:
-
-```c#
-// Unity Mathematics example
-void RandomNumberUnityMathematics()
-{
-   // Choose some non-zero seed and set up the random number generator state.
-   uint seed = 1;
-   Unity.Mathematics.Random rng = new Unity.Mathematics.Random(seed);
-
-   // [0, 1) exclusive
-   float randomFloat1 = rng.NextFloat();
-
-   // [-5, 5) exclusive
-   float randomFloat2 = rng.NextFloat(-5.0f, 5.0f);
-}
-```
\ No newline at end of file
diff --git a/src/Documentation~/vector-multiplication.md b/src/Documentation~/vector-multiplication.md
new file mode 100644
index 00000000..123fe6bb
--- /dev/null
+++ b/src/Documentation~/vector-multiplication.md
@@ -0,0 +1,16 @@
+# Vector multiplication
+
+To multiply vectors, use the `*`:
+
+```c#
+// Unity Mathematics example
+void ComponentwiseVectorMultiplyUnityMathematics()
+{
+   var v0 = new float4(2.0f, 4.0f, 6.0f, 8.0f);
+   var v1 = new float4(1.0f, -1.0f, 1.0f, -1.0f);
+   var result = v0 * v1;
+   // result == new float4(2.0f, -4.0f, 6.0f, -8.0f).
+}
+```
+
+This is a common way of writing [SIMD](https://en.wikipedia.org/wiki/Single_instruction,_multiple_data) code, which applies a single instruction to multiple data elements. Other operators such as addition, subtraction, and division work in the same way.
\ No newline at end of file

From 7844450f9a08f160a9133f1d594fee8c32b1c7ec Mon Sep 17 00:00:00 2001
From: Jo Petty <49957016+jo-unity@users.noreply.github.com>
Date: Mon, 4 Jul 2022 13:56:58 +0100
Subject: [PATCH 51/94] Update src/Documentation~/random-numbers.md

Co-authored-by: Dale Kim <3121968+unpacklo@users.noreply.github.com>
---
 src/Documentation~/random-numbers.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Documentation~/random-numbers.md b/src/Documentation~/random-numbers.md
index 753108e3..7cd30394 100644
--- a/src/Documentation~/random-numbers.md
+++ b/src/Documentation~/random-numbers.md
@@ -2,7 +2,7 @@
 
 To generate random numbers, you must create and manage the random number generator state yourself. This means you can control the random number generator state explicitly, which is useful it you're using parallel code, or if you want to make sure that one source of random numbers is seeded differently than another source.
 
-Once you set up the state, use [`NextFloat`](xref:Unity.Mathematics.Random.NextFloat) to get random floats. By default it returns random numbers between `[0, 1]`, exclusive:
+Once you set up the state, use [`NextFloat`](xref:Unity.Mathematics.Random.NextFloat) to get random floats. By default it returns random numbers between `[0, 1)`, exclusive:
 
 ```c#
 // Unity Mathematics example

From d41383b7335376333fb4b1ed91437b48601c7fc6 Mon Sep 17 00:00:00 2001
From: Jo Dawes <jo.dawes@unity3d.com>
Date: Mon, 4 Jul 2022 16:06:15 +0100
Subject: [PATCH 52/94] Updated docs based on feedback

Changed compatibility page, and the random numbers page
---
 src/Documentation~/compatibility.md  | 14 ++++++++------
 src/Documentation~/random-numbers.md |  4 ++--
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/Documentation~/compatibility.md b/src/Documentation~/compatibility.md
index 94d6f17c..5de185d1 100644
--- a/src/Documentation~/compatibility.md
+++ b/src/Documentation~/compatibility.md
@@ -1,15 +1,17 @@
-# Compatibility with `Mathf`
+# Compatibility with `UnityEngine` mathematics
 
-Unity Mathematics isn't implemented in the same way as the [`UnityEngine.Mathf`](https://docs.unity3d.com/ScriptReference/Mathf.html) struct in the core Unity engine. Because of this, if your application relies on the specific behaviors of `Mathf`, it might not be possible to use Unity Mathematics in your project. Also, if your project uses `Mathf` functions that have no corresponding Unity Mathematics function, or your code uses external plug-ins that depend on Unity types such as `Vector3`, or `Matrix4x4`, then you shouldn't use Unity Mathematics.
+If you want to Burst-compile your project, it's best practice to use the Unity Mathematics package by default and only use `Mathf` when necessary. Unity Mathematics isn't implemented in the same way as the [`UnityEngine.Mathf`](https://docs.unity3d.com/ScriptReference/Mathf.html) struct in the core Unity engine. Because of this, if your application relies on the specific behaviors of `Mathf`, you'll have to reimplement them to get similar behavior in Unity Mathematics. 
 
 >[!IMPORTANT]
 >For performance reasons, if your project uses the Mono compiler, you should continue to use the mathematical operations in `Mathf`, rather than Unity Mathematics.
 
-## Porting `Mathf` code to Unity Mathematics
+You can use both `Mathf` and Unity Mathematics methods in your project, but it might impact on the performance of your project because the conversions between the `UnityEngine` and `Unity.Mathematics` types such as `Vector3` to `float3` and vice-versa are performance-intensive. 
+
+## Porting `UnityEngine` code to `Unity.Mathematics`
 
 If you want to migrate code from `UnityEngine` to `Unity.Mathematics`, you need to make the following changes first:
 
-* `Vector4` to `float4`
-* Multiplications on vector or matrix objects to component multiplication with the `*` operator.
+* Update `UnityEngine` types to `Unity.Mathematics` types. For example, [`Vector4`](https://docs.unity3d.com/ScriptReference/Vector4.html) to [`float4`](xref:Unity.Mathematics.float4), and [`Quaternion`](https://docs.unity3d.com/ScriptReference/Quaternion.html) to [`quaternion`](xref:Unity.Mathematics.quaternion). These examples aren't exhaustive: see the [Scripting API reference](https://docs.unity3d.com/Packages/com.unity.mathematics@latest/index.html?subfolder=/api/index.html) for the full list of Unity Mathematics types available.
+* Update any operators involved in matrices or vectors. For example, the `Matrix4x4` multiplication operator implements matrix multiplication, but the `float4x4` multiplication operator implements componentwise multiplication.
 * Degrees to radians
-* How your code generates random numbers
\ No newline at end of file
+* How your code generates random numbers. `Random` in `Unity.Mathematics` works differently to [`Random`](https://docs.unity3d.com/ScriptReference/Random.html) in `UnityEngine`. You can completely control random number generation with `Random` in `Unity.Mathematics`, and it's instanced, rather than static. It's also exclusive with its upper bound, which is important to bear in mind if you want to convert `UnityEngine` code which is sensitive to the bounds. For more information, see the documentation on [Random numbers](random-numbers.md).
diff --git a/src/Documentation~/random-numbers.md b/src/Documentation~/random-numbers.md
index 7cd30394..5a09e9d9 100644
--- a/src/Documentation~/random-numbers.md
+++ b/src/Documentation~/random-numbers.md
@@ -1,6 +1,6 @@
 ## Random numbers
 
-To generate random numbers, you must create and manage the random number generator state yourself. This means you can control the random number generator state explicitly, which is useful it you're using parallel code, or if you want to make sure that one source of random numbers is seeded differently than another source.
+To generate random numbers, you must create and manage the random number generator state yourself with the [`Random`](xref:Unity.Mathematics.Random) struct. You can control the random number generator state explicitly, which is useful if you're using parallel code, or if you want to make sure that one source of random numbers is seeded differently than another source. You can also have as many `Random` instances as you like.
 
 Once you set up the state, use [`NextFloat`](xref:Unity.Mathematics.Random.NextFloat) to get random floats. By default it returns random numbers between `[0, 1)`, exclusive:
 
@@ -18,4 +18,4 @@ void RandomNumberUnityMathematics()
    // [-5, 5) exclusive
    float randomFloat2 = rng.NextFloat(-5.0f, 5.0f);
 }
-```
\ No newline at end of file
+```

From 27792767df03f4fc7b3d17a309079070c29696a7 Mon Sep 17 00:00:00 2001
From: Jo Dawes <49957016+jo-unity@users.noreply.github.com>
Date: Mon, 4 Jul 2022 16:53:06 +0100
Subject: [PATCH 53/94] Update src/Documentation~/4x4-matrices.md

Co-authored-by: James-Burr-Unity <61244495+James-Burr-Unity@users.noreply.github.com>
---
 src/Documentation~/4x4-matrices.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Documentation~/4x4-matrices.md b/src/Documentation~/4x4-matrices.md
index 05f092b8..22c705e9 100644
--- a/src/Documentation~/4x4-matrices.md
+++ b/src/Documentation~/4x4-matrices.md
@@ -17,7 +17,7 @@ void Build4x4UnityMathematics()
 
 ## Multiplying a 4×4 matrix
 
-Unity Mathematics defines the `*` operator differently to `UnityEngine`. The `*` operator for [`float4x4`](xref:Unity.Mathematics.float4x4) implements componentwise multiplication. If you multiply a `float4x4` of all 1s with 0.5 on the diagonal, you get back the half identity because the upper and lower triangles of the matrix are multiplied by the respective zero entries from `f4x4_HalfIdentity`:
+Unity Mathematics and `UnityEngine` define the `*` operator differently. The `*` operator for [`float4x4`](xref:Unity.Mathematics.float4x4) implements componentwise multiplication. If you multiply a `float4x4` of all 1s with 0.5 on the diagonal, you get back the half identity because the upper and lower triangles of the matrix are multiplied by the respective zero entries from `f4x4_HalfIdentity`:
 
 ```c#
 // Unity Mathematics example

From 75d8f4899319188323af729801712b274c2011c5 Mon Sep 17 00:00:00 2001
From: Jo Dawes <49957016+jo-unity@users.noreply.github.com>
Date: Mon, 4 Jul 2022 16:53:34 +0100
Subject: [PATCH 54/94] Update src/Documentation~/4x4-matrices.md

Co-authored-by: James-Burr-Unity <61244495+James-Burr-Unity@users.noreply.github.com>
---
 src/Documentation~/4x4-matrices.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Documentation~/4x4-matrices.md b/src/Documentation~/4x4-matrices.md
index 22c705e9..266ec670 100644
--- a/src/Documentation~/4x4-matrices.md
+++ b/src/Documentation~/4x4-matrices.md
@@ -36,7 +36,7 @@ void OperatorMultiply4x4UnityMathematics()
 
 Use the [`math.mul`](xref:Unity.Mathematics.math.mul*) method to multiply a 4×4 matrix and a 4D vector. If you supply a `float4x4` as the first parameter and a `float4` as the second, it performs a 4×4 matrix multiplication with a 4×1 column vector, which returns a 4×1 column vector as a `float4`.
 
-`math.mul` can also multiply a 1×4 row vector by a 4×4 matrix to produce a 1×4  row vector by taking a `float4` as the first parameter and a `float4×4` as the second. Unity Mathematics stores the row vector in a `float4` and it isn't treated as a separate type.
+`math.mul` can also multiply a 1×4 row vector by a 4×4 matrix to produce a 1×4 row vector by taking a `float4` as the first parameter and a `float4×4` as the second. Unity Mathematics stores the row vector in a `float4` and it isn't treated as a separate type.
 
 ```c#
 // Unity Mathematics example

From 0856b4fa49774557e8d99b181bbb643cca913f98 Mon Sep 17 00:00:00 2001
From: Jo Dawes <49957016+jo-unity@users.noreply.github.com>
Date: Mon, 4 Jul 2022 16:59:49 +0100
Subject: [PATCH 55/94] Update src/Documentation~/compatibility.md

Co-authored-by: James-Burr-Unity <61244495+James-Burr-Unity@users.noreply.github.com>
---
 src/Documentation~/compatibility.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Documentation~/compatibility.md b/src/Documentation~/compatibility.md
index 5de185d1..9113e0a4 100644
--- a/src/Documentation~/compatibility.md
+++ b/src/Documentation~/compatibility.md
@@ -5,7 +5,7 @@ If you want to Burst-compile your project, it's best practice to use the Unity M
 >[!IMPORTANT]
 >For performance reasons, if your project uses the Mono compiler, you should continue to use the mathematical operations in `Mathf`, rather than Unity Mathematics.
 
-You can use both `Mathf` and Unity Mathematics methods in your project, but it might impact on the performance of your project because the conversions between the `UnityEngine` and `Unity.Mathematics` types such as `Vector3` to `float3` and vice-versa are performance-intensive. 
+You can use both `Mathf` and Unity Mathematics methods in your project, but it might impact on the performance of your application because the conversions between the `UnityEngine` and `Unity.Mathematics` types such as `Vector3` to `float3` and vice-versa are performance-intensive. 
 
 ## Porting `UnityEngine` code to `Unity.Mathematics`
 

From 04fb13d15549a8e5b3db5ea6b788624e5a963f35 Mon Sep 17 00:00:00 2001
From: Jo Dawes <49957016+jo-unity@users.noreply.github.com>
Date: Mon, 4 Jul 2022 17:02:11 +0100
Subject: [PATCH 56/94] Update src/Documentation~/quaternion-multiplication.md

Co-authored-by: James-Burr-Unity <61244495+James-Burr-Unity@users.noreply.github.com>
---
 src/Documentation~/quaternion-multiplication.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Documentation~/quaternion-multiplication.md b/src/Documentation~/quaternion-multiplication.md
index b9415b84..d6f70f4d 100644
--- a/src/Documentation~/quaternion-multiplication.md
+++ b/src/Documentation~/quaternion-multiplication.md
@@ -1,6 +1,6 @@
 # Quaternion multiplication
 
-To rotate a quaternion, use the [`AxisAngle`](xref:Unity.Mathematics.quaternion.AxisAngle*) method. You specify the axis of rotation and the rotation around that axis, but supply the axis first and the angle second. Also, all the angles are in radians rather than degrees. `math.mul` multiplies the quaternion, just as with [matrices](4x4-matrices.md) and vectors.
+To rotate a quaternion, use the [`AxisAngle`](xref:Unity.Mathematics.quaternion.AxisAngle*) method. You need to specify the axis of rotation and the angle of rotation, in that order. All are in radians rather than degrees. `math.mul` multiplies the quaternion, just as with [matrices](4x4-matrices.md) and vectors.
 
 ```c#
 // Unity Mathematics example

From 80b9daee9826ac1d46a39c4fe19af67d3ef2f891 Mon Sep 17 00:00:00 2001
From: Bryan McNett <bryan@unity3d.com>
Date: Tue, 16 Aug 2022 10:38:41 -0700
Subject: [PATCH 57/94] including .csproj.meta files in the git repo (#226)

* including .csproj.meta files in the git repo

* Remove repository property to make upm-ci happy.

Co-authored-by: Dale Kim <3121968+unpacklo@users.noreply.github.com>
---
 .gitignore                                                 | 1 -
 src/Tests/Unity.Mathematics.Tests.csproj.meta              | 7 +++++++
 .../Unity.Mathematics.PerformanceTests.csproj.meta         | 7 +++++++
 src/Unity.Mathematics/Unity.Mathematics.csproj.meta        | 7 +++++++
 src/package.json                                           | 5 -----
 5 files changed, 21 insertions(+), 6 deletions(-)
 create mode 100644 src/Tests/Unity.Mathematics.Tests.csproj.meta
 create mode 100644 src/Unity.Mathematics.PerformanceTests/Unity.Mathematics.PerformanceTests.csproj.meta
 create mode 100644 src/Unity.Mathematics/Unity.Mathematics.csproj.meta

diff --git a/.gitignore b/.gitignore
index f2d2f5bb..8b75980d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,7 +8,6 @@ Library
 obj
 obj.meta
 # User-specific files
-*.csproj.meta
 *.csproj.user
 *.suo
 *.user
diff --git a/src/Tests/Unity.Mathematics.Tests.csproj.meta b/src/Tests/Unity.Mathematics.Tests.csproj.meta
new file mode 100644
index 00000000..24e5c128
--- /dev/null
+++ b/src/Tests/Unity.Mathematics.Tests.csproj.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: e393530e16da0c6498af8f6417806c74
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/src/Unity.Mathematics.PerformanceTests/Unity.Mathematics.PerformanceTests.csproj.meta b/src/Unity.Mathematics.PerformanceTests/Unity.Mathematics.PerformanceTests.csproj.meta
new file mode 100644
index 00000000..178e830f
--- /dev/null
+++ b/src/Unity.Mathematics.PerformanceTests/Unity.Mathematics.PerformanceTests.csproj.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 83a70727fa33a914d9c1049386e82be7
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj.meta b/src/Unity.Mathematics/Unity.Mathematics.csproj.meta
new file mode 100644
index 00000000..ebf3a017
--- /dev/null
+++ b/src/Unity.Mathematics/Unity.Mathematics.csproj.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: adc57cbbc95b9e449ba89e2bd869e8d9
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/src/package.json b/src/package.json
index 21c041d3..f99d7f78 100755
--- a/src/package.json
+++ b/src/package.json
@@ -8,10 +8,5 @@
         "unity"
     ],
     "dependencies": {
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/Unity-Technologies/Unity.Mathematics",
-        "revision":""
     }
 }

From 71e938fa6b9d05fce90ecac985786598f0efb65d Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Wed, 21 Sep 2022 17:16:25 -0700
Subject: [PATCH 58/94] Fix some doc errors. (#228)

* Fix some doc errors.

* Add nextpow2 to ceilpow2 documentation for searchability.

* Add AffineTransform.zero.
---
 src/Tests/Tests/Shared/TestAffineTransform.cs |  7 +++++++
 src/Unity.Mathematics/affine_transform.cs     |  9 ++++++++-
 src/Unity.Mathematics/math.cs                 | 10 ++++++++++
 3 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/src/Tests/Tests/Shared/TestAffineTransform.cs b/src/Tests/Tests/Shared/TestAffineTransform.cs
index 460650cd..a5b31efe 100644
--- a/src/Tests/Tests/Shared/TestAffineTransform.cs
+++ b/src/Tests/Tests/Shared/TestAffineTransform.cs
@@ -162,5 +162,12 @@ public static void affine_transform_transform_point()
             float3 txPt0 = transform(tx, pt);
             TestUtils.AreEqual(mPt0, txPt0, 0.0001f);
         }
+
+        [TestCompiler]
+        public static void affine_transform_zero()
+        {
+            TestUtils.AreEqual(float3x3.zero, AffineTransform.zero.rs);
+            TestUtils.AreEqual(float3.zero, AffineTransform.zero.t);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Unity.Mathematics/affine_transform.cs b/src/Unity.Mathematics/affine_transform.cs
index 33567b92..6ba30887 100644
--- a/src/Unity.Mathematics/affine_transform.cs
+++ b/src/Unity.Mathematics/affine_transform.cs
@@ -25,6 +25,11 @@ public struct AffineTransform : IEquatable<AffineTransform>, IFormattable
         /// <summary>An AffineTransform representing the identity transform.</summary>
         public static readonly AffineTransform identity = new AffineTransform(float3.zero, float3x3.identity);
 
+        /// <summary>
+        /// An AffineTransform zero value.
+        /// </summary>
+        public static readonly AffineTransform zero;
+
         /// <summary>Constructs an AffineTransform from a translation represented by a float3 vector and rotation represented by a unit quaternion.</summary>
         /// <param name="translation">The translation vector.</param>
         /// <param name="rotation">The rotation quaternion.</param>
@@ -94,11 +99,13 @@ public AffineTransform(float4x4 m)
 
         /// <summary>Implicit float3x4 cast operator.</summary>
         /// <param name="m">The AffineTransform.</param>
+        /// <returns>The converted AffineTransform.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator float3x4(AffineTransform m) { return float3x4(m.rs.c0, m.rs.c1, m.rs.c2, m.t); }
 
         /// <summary>Implicit float4x4 cast operator.</summary>
         /// <param name="m">The AffineTransform.</param>
+        /// <returns>The converted AffineTransform.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator float4x4(AffineTransform m) { return float4x4(float4(m.rs.c0, 0f), float4(m.rs.c1, 0f), float4(m.rs.c2, 0f), float4(m.t, 1f)); }
 
@@ -265,7 +272,7 @@ public static float3 transform(AffineTransform a, float3 pos)
         }
 
         /// <summary>Returns the inverse of an AffineTransform.</summary>
-        /// <param name="t">The AffineTransform to invert.</param>
+        /// <param name="a">The AffineTransform to invert.</param>
         /// <returns>The inverse AffineTransform.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static AffineTransform inverse(AffineTransform a)
diff --git a/src/Unity.Mathematics/math.cs b/src/Unity.Mathematics/math.cs
index f2ef33b7..26b0d378 100644
--- a/src/Unity.Mathematics/math.cs
+++ b/src/Unity.Mathematics/math.cs
@@ -5514,6 +5514,7 @@ public static ulong reversebits(ulong x)
 
 
         /// <summary>Returns the smallest power of two greater than or equal to the input.</summary>
+        /// <remarks>Also known as nextpow2.</remarks>
         /// <param name="x">Input value.</param>
         /// <returns>The smallest power of two greater than or equal to the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -5529,6 +5530,7 @@ public static int ceilpow2(int x)
         }
 
         /// <summary>Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input.</summary>
+        /// <remarks>Also known as nextpow2.</remarks>
         /// <param name="x">Input value.</param>
         /// <returns>The componentwise smallest power of two greater than or equal to the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -5544,6 +5546,7 @@ public static int2 ceilpow2(int2 x)
         }
 
         /// <summary>Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input.</summary>
+        /// <remarks>Also known as nextpow2.</remarks>
         /// <param name="x">Input value.</param>
         /// <returns>The componentwise smallest power of two greater than or equal to the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -5559,6 +5562,7 @@ public static int3 ceilpow2(int3 x)
         }
 
         /// <summary>Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input.</summary>
+        /// <remarks>Also known as nextpow2.</remarks>
         /// <param name="x">Input value.</param>
         /// <returns>The componentwise smallest power of two greater than or equal to the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -5575,6 +5579,7 @@ public static int4 ceilpow2(int4 x)
 
 
         /// <summary>Returns the smallest power of two greater than or equal to the input.</summary>
+        /// <remarks>Also known as nextpow2.</remarks>
         /// <param name="x">Input value.</param>
         /// <returns>The smallest power of two greater than or equal to the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -5590,6 +5595,7 @@ public static uint ceilpow2(uint x)
         }
 
         /// <summary>Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input.</summary>
+        /// <remarks>Also known as nextpow2.</remarks>
         /// <param name="x">Input value.</param>
         /// <returns>The componentwise smallest power of two greater than or equal to the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -5605,6 +5611,7 @@ public static uint2 ceilpow2(uint2 x)
         }
 
         /// <summary>Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input.</summary>
+        /// <remarks>Also known as nextpow2.</remarks>
         /// <param name="x">Input value.</param>
         /// <returns>The componentwise smallest power of two greater than or equal to the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -5620,6 +5627,7 @@ public static uint3 ceilpow2(uint3 x)
         }
 
         /// <summary>Returns the result of a componentwise calculation of the smallest power of two greater than or equal to the input.</summary>
+        /// <remarks>Also known as nextpow2.</remarks>
         /// <param name="x">Input value.</param>
         /// <returns>The componentwise smallest power of two greater than or equal to the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -5636,6 +5644,7 @@ public static uint4 ceilpow2(uint4 x)
 
 
         /// <summary>Returns the smallest power of two greater than or equal to the input.</summary>
+        /// <remarks>Also known as nextpow2.</remarks>
         /// <param name="x">Input value.</param>
         /// <returns>The smallest power of two greater than or equal to the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -5653,6 +5662,7 @@ public static long ceilpow2(long x)
 
 
         /// <summary>Returns the smallest power of two greater than or equal to the input.</summary>
+        /// <remarks>Also known as nextpow2.</remarks>
         /// <param name="x">Input value.</param>
         /// <returns>The smallest power of two greater than or equal to the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

From df595bb0736b1b767984f8510214821a49fa54ca Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Mon, 26 Sep 2022 18:27:50 -0700
Subject: [PATCH 59/94] Fix solution to refer to renamed code gen project.
 (#227)

---
 src/Unity.Mathematics.sln | 16 ++--------------
 1 file changed, 2 insertions(+), 14 deletions(-)

diff --git a/src/Unity.Mathematics.sln b/src/Unity.Mathematics.sln
index 19d5c88a..7651ca6e 100644
--- a/src/Unity.Mathematics.sln
+++ b/src/Unity.Mathematics.sln
@@ -5,8 +5,6 @@ VisualStudioVersion = 16.0.29806.167
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Unity.Mathematics", "Unity.Mathematics\Unity.Mathematics.csproj", "{19810344-7387-4155-935F-BDD5CC61F0BF}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Unity.Mathematics.CodeGen", "Unity.Mathematics.CodeGen\Unity.Mathematics.CodeGen.csproj", "{293EBCD6-CACD-4DA8-A518-FBC629268C0F}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "General", "General", "{B11ECCE1-1A78-40B2-956F-CBE615FF5DF9}"
 	ProjectSection(SolutionItems) = preProject
 		CHANGELOG.md = CHANGELOG.md
@@ -16,6 +14,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "General", "General", "{B11E
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Unity.Mathematics.Tests", "Tests\Unity.Mathematics.Tests.csproj", "{2E7C74D3-42F1-482F-8BB7-E199D9E3B412}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Unity.Mathematics.CodeGen", "Unity.Mathematics.CodeGen~\Unity.Mathematics.CodeGen.csproj", "{293EBCD6-CACD-4DA8-A518-FBC629268C0F}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -38,18 +38,6 @@ Global
 		{19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x64.Build.0 = Release|x64
 		{19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x86.ActiveCfg = Release|Any CPU
 		{19810344-7387-4155-935F-BDD5CC61F0BF}.Release|x86.Build.0 = Release|Any CPU
-		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|x64.ActiveCfg = Debug|Any CPU
-		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|x64.Build.0 = Debug|Any CPU
-		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|x86.Build.0 = Debug|Any CPU
-		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|Any CPU.Build.0 = Release|Any CPU
-		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|x64.ActiveCfg = Release|Any CPU
-		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|x64.Build.0 = Release|Any CPU
-		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|x86.ActiveCfg = Release|Any CPU
-		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|x86.Build.0 = Release|Any CPU
 		{2E7C74D3-42F1-482F-8BB7-E199D9E3B412}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{2E7C74D3-42F1-482F-8BB7-E199D9E3B412}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{2E7C74D3-42F1-482F-8BB7-E199D9E3B412}.Debug|x64.ActiveCfg = Debug|Any CPU

From 91445d8576f9313bc4b74e86b4e6adb0b62edca9 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Wed, 28 Sep 2022 14:11:38 -0700
Subject: [PATCH 60/94] Add configurations to build. (#230)

---
 src/Unity.Mathematics.sln | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/Unity.Mathematics.sln b/src/Unity.Mathematics.sln
index 7651ca6e..a0ea6974 100644
--- a/src/Unity.Mathematics.sln
+++ b/src/Unity.Mathematics.sln
@@ -50,6 +50,10 @@ Global
 		{2E7C74D3-42F1-482F-8BB7-E199D9E3B412}.Release|x64.Build.0 = Release|Any CPU
 		{2E7C74D3-42F1-482F-8BB7-E199D9E3B412}.Release|x86.ActiveCfg = Release|Any CPU
 		{2E7C74D3-42F1-482F-8BB7-E199D9E3B412}.Release|x86.Build.0 = Release|Any CPU
+		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

From f1a296b9ed3021b980abb69d2a66d20fe1453d5e Mon Sep 17 00:00:00 2001
From: kevinmv <45053404+kevinmv@users.noreply.github.com>
Date: Thu, 27 Apr 2023 19:37:14 -0400
Subject: [PATCH 61/94] Update License to 2023

---
 LICENSE.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/LICENSE.md b/LICENSE.md
index a95cdfbe..0c7f3fac 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,4 +1,4 @@
-com.unity.mathematics copyright © 2022 Unity Technologies ApS
+com.unity.mathematics copyright © 2023 Unity Technologies ApS
 
 Licensed under the Unity Companion License for Unity-dependent projects (see https://unity3d.com/legal/licenses/unity_companion_license).
-Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.
\ No newline at end of file
+Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.

From c8d9473ead179d0d49d72147825256e5f7cf5228 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Thu, 27 Apr 2023 17:02:09 -0700
Subject: [PATCH 62/94] Update package copy of license file.

Probably should figure out which one of these is the authoritative
one...
---
 src/LICENSE.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/LICENSE.md b/src/LICENSE.md
index a95cdfbe..1f5c0f44 100755
--- a/src/LICENSE.md
+++ b/src/LICENSE.md
@@ -1,4 +1,4 @@
-com.unity.mathematics copyright © 2022 Unity Technologies ApS
+com.unity.mathematics copyright © 2023 Unity Technologies ApS
 
 Licensed under the Unity Companion License for Unity-dependent projects (see https://unity3d.com/legal/licenses/unity_companion_license).
 Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.
\ No newline at end of file

From 29a4f3fb3c0f2fc5f3920aebb69e27b277847c3d Mon Sep 17 00:00:00 2001
From: Peter Lu <peter.lu@unity3d.com>
Date: Mon, 5 Jun 2023 15:07:38 -0400
Subject: [PATCH 63/94] -Updated upm-ci.yml by removing the
 2020.3/partner/staging branch -Added LTS branches for 2021 and 2022 -Added
 2023.1 version

---
 .yamato/upm-ci.yml | 28 ++++++++++++----------------
 1 file changed, 12 insertions(+), 16 deletions(-)

diff --git a/.yamato/upm-ci.yml b/.yamato/upm-ci.yml
index 7abddb97..cbde2bd8 100644
--- a/.yamato/upm-ci.yml
+++ b/.yamato/upm-ci.yml
@@ -33,14 +33,12 @@ validate_editor_versions:
     display_name: "2019.4"
   - version: "2020.3"
     display_name: "2020.3"
-  - version: "2021.1"
-    display_name: "2021.1"
-  - version: "2021.2"
-    display_name: "2021.2"
-  - version: "2022.1"
-    display_name: "2022.1"
-  - version: "2020.3/partner/staging"
-    display_name: "2020.3_partner_staging"
+  - version: "2021.3"
+    display_name: "2021.3"
+  - version: "2022.3"
+    display_name: "2022.3"
+  - version: "2023.1"
+    display_name: "2023.1"
   - version: "trunk"
     display_name: "trunk"
 
@@ -56,14 +54,12 @@ package_tests_editor_versions:
     display_name: "2019.4"
   - version: "2020.3"
     display_name: "2020.3"
-  - version: "2021.1"
-    display_name: "2021.1"
-  - version: "2021.2"
-    display_name: "2021.2"
-  - version: "2022.1"
-    display_name: "2022.1"
-  - version: "2020.3/partner/staging"
-    display_name: "2020.3_partner_staging"
+  - version: "2021.3"
+    display_name: "2021.3"
+  - version: "2022.3"
+    display_name: "2022.3"
+  - version: "2023.1"
+    display_name: "2023.1"
   - version: "trunk"
     display_name: "trunk"
 ---

From 76466c7fbbdcad835c25cd31c7c20a5faccd6db5 Mon Sep 17 00:00:00 2001
From: Jonathan Mankin <jonathan.mankin@unity3d.com>
Date: Wed, 12 Jul 2023 13:24:23 -0700
Subject: [PATCH 64/94] update changelog and version

---
 src/CHANGELOG.md | 35 +++++++++++++++++++----------------
 src/package.json |  2 +-
 2 files changed, 20 insertions(+), 17 deletions(-)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index 7e856def..4a2f3065 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -1,6 +1,15 @@
 # Changelog
 
 ## [Unreleased]
+### Added
+### Changed
+### Deprecated
+### Removed
+### Fixed
+
+
+## [1.3.0] 2023-07-12
+
 ### Added
 * Added `math.square` to compute the square (x * x).
 * Added `math.orthonormal_basis` to compute an orthonormal basis from a single unit length vector.
@@ -13,31 +22,32 @@
 * Added `math.scaleMul` to scale rows of a float3x3 with scaling coefficients in a float3.
 * Added `AffineTransform` type.
 * Added `PI2`, `PIHALF`, `TAU`, `TODEGREES` and `TORADIANS` constants.
+
 ### Changed
 * `asfloat(uint)`, `asuint(float)`, `asint(float)` and other related methods are now faster in mono without Burst. Other methods which use these will see a performance improvement.
 * Modified `quaternion.nlerp` to be branchless.
 * More descriptive parameter names for many methods in `math` class.
 * Made `Il2CppEagerStaticClassConstructionAttribute` internal to avoid conflicts with other definitions outside of the package.
-### Deprecated
-### Removed
-### Fixed
 
-## [1.2.5] - 2021-11-01
-### Added
+## [1.2.6] - 2022-02-11
+
 ### Changed
-### Deprecated
-### Removed
+* Made Il2CppEagerStaticClassConstructionAttribute internal to avoid conflicts with other definitions outside of the package. 
+
+## [1.2.5] - 2021-11-01
+
 ### Fixed
 * Fixed property drawing when manually drawing a property that was hidden with [HideInInspector].
 
 ## [1.2.4] - 2021-09-22
+
 ### Added
 * Added `[Il2CppEagerStaticClassConstruction]` to Unity.Mathematics types to run static constructors at startup. This improves IL2CPP performance slightly for types that have static constructors.
+
 ### Changed
 * License file updated to satisfy Unity's package validation tests.
 * Changed noise documentation in comments to xmldoc comments.
-### Deprecated
-### Removed
+
 ### Fixed
 * Fixed Equals(object) override which did not check type before casting. This could cause exceptions to be thrown when the object did not match the expected type.
 * Fixed incorrect `math.tzcnt` documentation which mentioned leading zero counts instead of trailing zero counts.
@@ -46,10 +56,6 @@
 
 ## [1.2.1] - 2020-08-06
 
-### Added
-### Changed
-### Deprecated
-### Removed
 ### Fixed
 * Fixed warnings for meta files existing even though the files they represent did not exist.
 
@@ -73,9 +79,6 @@
 * Added some performance tests which can be run from the Unity test project.
 * Added `Random.CreateFromIndex()` to assist in creating Random instances from loop indices.
 
-### Changed
-### Deprecated
-### Removed
 ### Fixed
 * Fixed documentation bug where `quaternion.RotateX/Y/Z` referred to a `float4x4` instead of quaternion.
 * Fixed code generation bugs which could cause Windows and Mac to generate different test code.
diff --git a/src/package.json b/src/package.json
index f99d7f78..65b75fc8 100755
--- a/src/package.json
+++ b/src/package.json
@@ -1,7 +1,7 @@
 {
     "name": "com.unity.mathematics",
     "displayName": "Mathematics",
-    "version": "1.2.5",
+    "version": "1.3.0",
     "unity": "2018.3",
     "description": "Unity's C# SIMD math library providing vector types and math functions with a shader like syntax.",
     "keywords": [

From 97c192a7ae15d3b01b48b4c8104339b57a8c8578 Mon Sep 17 00:00:00 2001
From: Jonathan Mankin <jonathan.mankin@unity3d.com>
Date: Thu, 27 Jul 2023 14:32:15 -0700
Subject: [PATCH 65/94] minor changelog fix

Sorry.
---
 src/CHANGELOG.md | 2 +-
 src/package.json | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index 4a2f3065..0ee687ff 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -8,7 +8,7 @@
 ### Fixed
 
 
-## [1.3.0] 2023-07-12
+## [1.3.1] - 2023-07-12
 
 ### Added
 * Added `math.square` to compute the square (x * x).
diff --git a/src/package.json b/src/package.json
index 65b75fc8..5e0509b2 100755
--- a/src/package.json
+++ b/src/package.json
@@ -1,7 +1,7 @@
 {
     "name": "com.unity.mathematics",
     "displayName": "Mathematics",
-    "version": "1.3.0",
+    "version": "1.3.1",
     "unity": "2018.3",
     "description": "Unity's C# SIMD math library providing vector types and math functions with a shader like syntax.",
     "keywords": [

From 8a6d6fc400f396fc7be22fcf5bcae4721cb6fb4a Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Mon, 21 Aug 2023 19:03:04 -0700
Subject: [PATCH 66/94] ECSB-529 ECSB-506 Fix arm hash crash (#241)

Fix `math.hash` crash with arm 32 bit il2cpp builds.
---
 .yamato/upm-ci.yml                            |  21 +-
 .../Assets/Scenes/SampleScene.unity           | 133 ++-
 .../Scenes/SampleSceneSettings.lighting       |  66 ++
 .../Scenes/SampleSceneSettings.lighting.meta  |   8 +
 .../Packages/manifest.json                    |  12 +-
 .../ProjectSettings/EditorBuildSettings.asset |   5 +-
 .../ProjectSettings/GraphicsSettings.asset    |   4 +
 .../ProjectSettings/ProjectSettings.asset     | 303 +++++--
 .../ProjectSettings/ProjectVersion.txt        |   4 +-
 .../UnityConnectSettings.asset                |   2 +
 src/CHANGELOG.md                              |   2 +-
 src/Tests/Tests/Shared/TestAffineTransform.cs |  26 +-
 src/Tests/Tests/Shared/TestBitmanipulation.cs | 122 +--
 src/Tests/Tests/Shared/TestBool2.gen.cs       |  42 +-
 src/Tests/Tests/Shared/TestBool2x2.gen.cs     |  34 +-
 src/Tests/Tests/Shared/TestBool2x3.gen.cs     |  34 +-
 src/Tests/Tests/Shared/TestBool2x4.gen.cs     |  34 +-
 src/Tests/Tests/Shared/TestBool3.gen.cs       |  42 +-
 src/Tests/Tests/Shared/TestBool3x2.gen.cs     |  34 +-
 src/Tests/Tests/Shared/TestBool3x3.gen.cs     |  34 +-
 src/Tests/Tests/Shared/TestBool3x4.gen.cs     |  34 +-
 src/Tests/Tests/Shared/TestBool4.gen.cs       |  42 +-
 src/Tests/Tests/Shared/TestBool4x2.gen.cs     |  34 +-
 src/Tests/Tests/Shared/TestBool4x3.gen.cs     |  34 +-
 src/Tests/Tests/Shared/TestBool4x4.gen.cs     |  34 +-
 src/Tests/Tests/Shared/TestDouble2.gen.cs     |  98 +--
 src/Tests/Tests/Shared/TestDouble2x2.gen.cs   |  84 +-
 src/Tests/Tests/Shared/TestDouble2x3.gen.cs   |  82 +-
 src/Tests/Tests/Shared/TestDouble2x4.gen.cs   |  82 +-
 src/Tests/Tests/Shared/TestDouble3.gen.cs     |  98 +--
 src/Tests/Tests/Shared/TestDouble3x2.gen.cs   |  82 +-
 src/Tests/Tests/Shared/TestDouble3x3.gen.cs   |  84 +-
 src/Tests/Tests/Shared/TestDouble3x4.gen.cs   |  82 +-
 src/Tests/Tests/Shared/TestDouble4.gen.cs     |  98 +--
 src/Tests/Tests/Shared/TestDouble4x2.gen.cs   |  82 +-
 src/Tests/Tests/Shared/TestDouble4x3.gen.cs   |  82 +-
 src/Tests/Tests/Shared/TestDouble4x4.gen.cs   |  84 +-
 src/Tests/Tests/Shared/TestFloat2.gen.cs      |  98 +--
 src/Tests/Tests/Shared/TestFloat2x2.gen.cs    |  84 +-
 src/Tests/Tests/Shared/TestFloat2x3.gen.cs    |  82 +-
 src/Tests/Tests/Shared/TestFloat2x4.gen.cs    |  82 +-
 src/Tests/Tests/Shared/TestFloat3.gen.cs      |  98 +--
 src/Tests/Tests/Shared/TestFloat3x2.gen.cs    |  82 +-
 src/Tests/Tests/Shared/TestFloat3x3.gen.cs    |  84 +-
 src/Tests/Tests/Shared/TestFloat3x4.gen.cs    |  82 +-
 src/Tests/Tests/Shared/TestFloat4.gen.cs      |  98 +--
 src/Tests/Tests/Shared/TestFloat4x2.gen.cs    |  82 +-
 src/Tests/Tests/Shared/TestFloat4x3.gen.cs    |  82 +-
 src/Tests/Tests/Shared/TestFloat4x4.gen.cs    |  84 +-
 src/Tests/Tests/Shared/TestHalf.cs            |  90 +-
 src/Tests/Tests/Shared/TestInt2.gen.cs        | 122 +--
 src/Tests/Tests/Shared/TestInt2x2.gen.cs      | 108 +--
 src/Tests/Tests/Shared/TestInt2x3.gen.cs      | 106 +--
 src/Tests/Tests/Shared/TestInt2x4.gen.cs      | 106 +--
 src/Tests/Tests/Shared/TestInt3.gen.cs        | 122 +--
 src/Tests/Tests/Shared/TestInt3x2.gen.cs      | 106 +--
 src/Tests/Tests/Shared/TestInt3x3.gen.cs      | 108 +--
 src/Tests/Tests/Shared/TestInt3x4.gen.cs      | 106 +--
 src/Tests/Tests/Shared/TestInt4.gen.cs        | 122 +--
 src/Tests/Tests/Shared/TestInt4x2.gen.cs      | 106 +--
 src/Tests/Tests/Shared/TestInt4x3.gen.cs      | 106 +--
 src/Tests/Tests/Shared/TestInt4x4.gen.cs      | 108 +--
 src/Tests/Tests/Shared/TestMath.cs            | 568 ++++++------
 src/Tests/Tests/Shared/TestMath.gen.cs        | 820 +++++++++---------
 src/Tests/Tests/Shared/TestMatrix.cs          | 122 +--
 src/Tests/Tests/Shared/TestMinMaxAABB.cs      |  90 +-
 src/Tests/Tests/Shared/TestPlane.cs           |  44 +-
 src/Tests/Tests/Shared/TestQuaternion.cs      |  56 +-
 src/Tests/Tests/Shared/TestRigidTransform.cs  |  16 +-
 src/Tests/Tests/Shared/TestSvd.cs             |  16 +-
 src/Tests/Tests/Shared/TestUint2.gen.cs       | 122 +--
 src/Tests/Tests/Shared/TestUint2x2.gen.cs     | 108 +--
 src/Tests/Tests/Shared/TestUint2x3.gen.cs     | 106 +--
 src/Tests/Tests/Shared/TestUint2x4.gen.cs     | 106 +--
 src/Tests/Tests/Shared/TestUint3.gen.cs       | 122 +--
 src/Tests/Tests/Shared/TestUint3x2.gen.cs     | 106 +--
 src/Tests/Tests/Shared/TestUint3x3.gen.cs     | 108 +--
 src/Tests/Tests/Shared/TestUint3x4.gen.cs     | 106 +--
 src/Tests/Tests/Shared/TestUint4.gen.cs       | 122 +--
 src/Tests/Tests/Shared/TestUint4x2.gen.cs     | 106 +--
 src/Tests/Tests/Shared/TestUint4x3.gen.cs     | 106 +--
 src/Tests/Tests/Shared/TestUint4x4.gen.cs     | 108 +--
 src/Tests/Tests/TestMath2.cs                  |  69 +-
 src/Tests/Tests/TestRandom.cs                 | 232 ++---
 src/Tests/Unity.Mathematics.Tests.asmdef      |  24 +-
 .../VectorGenerator.cs                        |   4 +-
 .../TestHash.cs                               |  58 ++
 .../TestHash.cs.meta                          |  11 +
 src/Unity.Mathematics.sln                     |   8 +
 src/Unity.Mathematics/math.cs                 |  87 +-
 90 files changed, 4366 insertions(+), 3817 deletions(-)
 create mode 100644 Unity.Mathematics.TestProject/Assets/Scenes/SampleSceneSettings.lighting
 create mode 100644 Unity.Mathematics.TestProject/Assets/Scenes/SampleSceneSettings.lighting.meta
 create mode 100644 src/Unity.Mathematics.PerformanceTests/TestHash.cs
 create mode 100644 src/Unity.Mathematics.PerformanceTests/TestHash.cs.meta

diff --git a/.yamato/upm-ci.yml b/.yamato/upm-ci.yml
index cbde2bd8..2a554b38 100644
--- a/.yamato/upm-ci.yml
+++ b/.yamato/upm-ci.yml
@@ -27,12 +27,6 @@ upmci_platforms:
     flavor: b1.large
 
 validate_editor_versions:
-  - version: "2018.4"
-    display_name: "2018.4"
-  - version: "2019.4"
-    display_name: "2019.4"
-  - version: "2020.3"
-    display_name: "2020.3"
   - version: "2021.3"
     display_name: "2021.3"
   - version: "2022.3"
@@ -43,17 +37,6 @@ validate_editor_versions:
     display_name: "trunk"
 
 package_tests_editor_versions:
-  # 2018.3 shows up here but not under validate_editor_versions because package validation is no longer
-  # supported on 2018.3 but Mathematics still supports it so we need to be able to test it. CI jobs
-  # from this list will run package tests only instead of the full validation suite.
-  - version: "2018.3"
-    display_name: "2018.3"
-  - version: "2018.4"
-    display_name: "2018.4"
-  - version: "2019.4"
-    display_name: "2019.4"
-  - version: "2020.3"
-    display_name: "2020.3"
   - version: "2021.3"
     display_name: "2021.3"
   - version: "2022.3"
@@ -96,7 +79,7 @@ package_tests_minimal:
   name: Package tests minimal
   dependencies:
   {% for platform in upmci_platforms %}
-    - .yamato/upm-ci.yml#package_tests_{{platform.name}}_2018.3
+    - .yamato/upm-ci.yml#package_tests_{{platform.name}}_2021.3
   {% endfor %}
 
 validate_package_minimal:
@@ -108,7 +91,7 @@ validate_package_minimal:
   commands:
     - npm install upm-ci-utils@stable --registry https://artifactory.prd.cds.internal.unity3d.com/artifactory/api/npm/upm-npm -g
     - upm-ci package pack --package-path src/
-    - upm-ci package test --package-path src/ --unity-version 2019.4
+    - upm-ci package test --package-path src/ --unity-version 2021.3
   artifacts:
     packages:
       paths:
diff --git a/Unity.Mathematics.TestProject/Assets/Scenes/SampleScene.unity b/Unity.Mathematics.TestProject/Assets/Scenes/SampleScene.unity
index 7cdec2a0..b819a102 100644
--- a/Unity.Mathematics.TestProject/Assets/Scenes/SampleScene.unity
+++ b/Unity.Mathematics.TestProject/Assets/Scenes/SampleScene.unity
@@ -38,24 +38,23 @@ RenderSettings:
   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 705507994}
-  m_IndirectSpecularColor: {r: 0.44657898, g: 0.4964133, b: 0.5748178, a: 1}
+  m_IndirectSpecularColor: {r: 0.44402242, g: 0.49316543, b: 0.5722324, a: 1}
   m_UseRadianceAmbientProbe: 0
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
-  serializedVersion: 11
+  serializedVersion: 12
   m_GIWorkflowMode: 0
   m_GISettings:
     serializedVersion: 2
     m_BounceScale: 1
     m_IndirectOutputScale: 1
     m_AlbedoBoost: 1
-    m_TemporalCoherenceThreshold: 1
     m_EnvironmentLightingMode: 0
     m_EnableBakedLightmaps: 1
     m_EnableRealtimeLightmaps: 1
   m_LightmapEditorSettings:
-    serializedVersion: 10
+    serializedVersion: 12
     m_Resolution: 2
     m_BakeResolution: 40
     m_AtlasSize: 1024
@@ -63,6 +62,7 @@ LightmapSettings:
     m_AOMaxDistance: 1
     m_CompAOExponent: 1
     m_CompAOExponentDirect: 0
+    m_ExtractAmbientOcclusion: 0
     m_Padding: 2
     m_LightmapParameters: {fileID: 0}
     m_LightmapsBakeMode: 1
@@ -77,10 +77,16 @@ LightmapSettings:
     m_PVRDirectSampleCount: 32
     m_PVRSampleCount: 500
     m_PVRBounces: 2
+    m_PVREnvironmentSampleCount: 500
+    m_PVREnvironmentReferencePointCount: 2048
+    m_PVRFilteringMode: 2
+    m_PVRDenoiserTypeDirect: 0
+    m_PVRDenoiserTypeIndirect: 0
+    m_PVRDenoiserTypeAO: 0
     m_PVRFilterTypeDirect: 0
     m_PVRFilterTypeIndirect: 0
     m_PVRFilterTypeAO: 0
-    m_PVRFilteringMode: 1
+    m_PVREnvironmentMIS: 0
     m_PVRCulling: 1
     m_PVRFilteringGaussRadiusDirect: 1
     m_PVRFilteringGaussRadiusIndirect: 5
@@ -88,15 +94,18 @@ LightmapSettings:
     m_PVRFilteringAtrousPositionSigmaDirect: 0.5
     m_PVRFilteringAtrousPositionSigmaIndirect: 2
     m_PVRFilteringAtrousPositionSigmaAO: 1
-    m_ShowResolutionOverlay: 1
+    m_ExportTrainingData: 0
+    m_TrainingDataDestination: TrainingData
+    m_LightProbeSampleCountMultiplier: 4
   m_LightingDataAsset: {fileID: 0}
-  m_UseShadowmask: 1
+  m_LightingSettings: {fileID: 4890085278179872738, guid: 20c8488ac153b4f45944c2d7c85a094e,
+    type: 2}
 --- !u!196 &4
 NavMeshSettings:
   serializedVersion: 2
   m_ObjectHideFlags: 0
   m_BuildSettings:
-    serializedVersion: 2
+    serializedVersion: 3
     agentTypeID: 0
     agentRadius: 0.5
     agentHeight: 2
@@ -109,15 +118,49 @@ NavMeshSettings:
     cellSize: 0.16666667
     manualTileSize: 0
     tileSize: 256
-    accuratePlacement: 0
+    buildHeightMesh: 0
+    maxJobWorkers: 0
+    preserveTilesOutsideBounds: 0
     debug:
       m_Flags: 0
   m_NavMeshData: {fileID: 0}
+--- !u!1 &206998647
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 206998649}
+  m_Layer: 0
+  m_Name: GameObject
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &206998649
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 206998647}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &705507993
 GameObject:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
   serializedVersion: 6
   m_Component:
   - component: {fileID: 705507995}
@@ -133,15 +176,18 @@ GameObject:
 Light:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 705507993}
   m_Enabled: 1
-  serializedVersion: 8
+  serializedVersion: 10
   m_Type: 1
+  m_Shape: 0
   m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
   m_Intensity: 1
   m_Range: 10
   m_SpotAngle: 30
+  m_InnerSpotAngle: 21.80208
   m_CookieSize: 10
   m_Shadows:
     m_Type: 2
@@ -151,6 +197,24 @@ Light:
     m_Bias: 0.05
     m_NormalBias: 0.4
     m_NearPlane: 0.2
+    m_CullingMatrixOverride:
+      e00: 1
+      e01: 0
+      e02: 0
+      e03: 0
+      e10: 0
+      e11: 1
+      e12: 0
+      e13: 0
+      e20: 0
+      e21: 0
+      e22: 1
+      e23: 0
+      e30: 0
+      e31: 0
+      e32: 0
+      e33: 1
+    m_UseCullingMatrixOverride: 0
   m_Cookie: {fileID: 0}
   m_DrawHalo: 0
   m_Flare: {fileID: 0}
@@ -158,32 +222,39 @@ Light:
   m_CullingMask:
     serializedVersion: 2
     m_Bits: 4294967295
+  m_RenderingLayerMask: 1
   m_Lightmapping: 1
   m_LightShadowCasterMode: 0
   m_AreaSize: {x: 1, y: 1}
   m_BounceIntensity: 1
   m_ColorTemperature: 6570
   m_UseColorTemperature: 0
+  m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 0}
+  m_UseBoundingSphereOverride: 0
+  m_UseViewFrustumForShadowCasterCull: 1
   m_ShadowRadius: 0
   m_ShadowAngle: 0
 --- !u!4 &705507995
 Transform:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 705507993}
+  serializedVersion: 2
   m_LocalRotation: {x: 0.40821788, y: -0.23456968, z: 0.10938163, w: 0.8754261}
   m_LocalPosition: {x: 0, y: 3, z: 0}
   m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
   m_Children: []
   m_Father: {fileID: 0}
-  m_RootOrder: 1
   m_LocalEulerAnglesHint: {x: 50, y: -30, z: 0}
 --- !u!1 &963194225
 GameObject:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
   serializedVersion: 6
   m_Component:
   - component: {fileID: 963194228}
@@ -200,24 +271,35 @@ GameObject:
 AudioListener:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 963194225}
   m_Enabled: 1
 --- !u!20 &963194227
 Camera:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 963194225}
   m_Enabled: 1
   serializedVersion: 2
   m_ClearFlags: 1
   m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
   m_projectionMatrixMode: 1
-  m_SensorSize: {x: 36, y: 24}
-  m_LensShift: {x: 0, y: 0}
   m_GateFitMode: 2
+  m_FOVAxisMode: 0
+  m_Iso: 200
+  m_ShutterSpeed: 0.005
+  m_Aperture: 16
+  m_FocusDistance: 10
   m_FocalLength: 50
+  m_BladeCount: 5
+  m_Curvature: {x: 2, y: 11}
+  m_BarrelClipping: 0.25
+  m_Anamorphism: 0
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
   m_NormalizedViewPortRect:
     serializedVersion: 2
     x: 0
@@ -248,12 +330,21 @@ Camera:
 Transform:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 963194225}
+  serializedVersion: 2
   m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
   m_LocalPosition: {x: 0, y: 1, z: -10}
   m_LocalScale: {x: 1, y: 1, z: 1}
+  m_ConstrainProportionsScale: 0
   m_Children: []
   m_Father: {fileID: 0}
-  m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1660057539 &9223372036854775807
+SceneRoots:
+  m_ObjectHideFlags: 0
+  m_Roots:
+  - {fileID: 963194228}
+  - {fileID: 705507995}
+  - {fileID: 206998649}
diff --git a/Unity.Mathematics.TestProject/Assets/Scenes/SampleSceneSettings.lighting b/Unity.Mathematics.TestProject/Assets/Scenes/SampleSceneSettings.lighting
new file mode 100644
index 00000000..e595ed65
--- /dev/null
+++ b/Unity.Mathematics.TestProject/Assets/Scenes/SampleSceneSettings.lighting
@@ -0,0 +1,66 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!850595691 &4890085278179872738
+LightingSettings:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: SampleSceneSettings
+  serializedVersion: 6
+  m_GIWorkflowMode: 0
+  m_EnableBakedLightmaps: 1
+  m_EnableRealtimeLightmaps: 1
+  m_RealtimeEnvironmentLighting: 1
+  m_BounceScale: 1
+  m_AlbedoBoost: 1
+  m_IndirectOutputScale: 1
+  m_UsingShadowmask: 1
+  m_BakeBackend: 1
+  m_LightmapMaxSize: 1024
+  m_BakeResolution: 40
+  m_Padding: 2
+  m_LightmapCompression: 3
+  m_AO: 0
+  m_AOMaxDistance: 1
+  m_CompAOExponent: 1
+  m_CompAOExponentDirect: 0
+  m_ExtractAO: 0
+  m_MixedBakeMode: 2
+  m_LightmapsBakeMode: 1
+  m_FilterMode: 1
+  m_LightmapParameters: {fileID: 15204, guid: 0000000000000000f000000000000000, type: 0}
+  m_ExportTrainingData: 0
+  m_TrainingDataDestination: TrainingData
+  m_RealtimeResolution: 2
+  m_ForceWhiteAlbedo: 0
+  m_ForceUpdates: 0
+  m_FinalGather: 0
+  m_FinalGatherRayCount: 256
+  m_FinalGatherFiltering: 1
+  m_PVRCulling: 1
+  m_PVRSampling: 1
+  m_PVRDirectSampleCount: 32
+  m_PVRSampleCount: 512
+  m_PVREnvironmentSampleCount: 512
+  m_PVREnvironmentReferencePointCount: 2048
+  m_LightProbeSampleCountMultiplier: 4
+  m_PVRBounces: 2
+  m_PVRMinBounces: 2
+  m_PVREnvironmentImportanceSampling: 0
+  m_PVRFilteringMode: 2
+  m_PVRDenoiserTypeDirect: 0
+  m_PVRDenoiserTypeIndirect: 0
+  m_PVRDenoiserTypeAO: 0
+  m_PVRFilterTypeDirect: 0
+  m_PVRFilterTypeIndirect: 0
+  m_PVRFilterTypeAO: 0
+  m_PVRFilteringGaussRadiusDirect: 1
+  m_PVRFilteringGaussRadiusIndirect: 5
+  m_PVRFilteringGaussRadiusAO: 2
+  m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+  m_PVRFilteringAtrousPositionSigmaIndirect: 2
+  m_PVRFilteringAtrousPositionSigmaAO: 1
+  m_PVRTiledBaking: 0
+  m_NumRaysToShootPerTexel: -1
+  m_RespectSceneVisibilityWhenBakingGI: 0
diff --git a/Unity.Mathematics.TestProject/Assets/Scenes/SampleSceneSettings.lighting.meta b/Unity.Mathematics.TestProject/Assets/Scenes/SampleSceneSettings.lighting.meta
new file mode 100644
index 00000000..daa2a351
--- /dev/null
+++ b/Unity.Mathematics.TestProject/Assets/Scenes/SampleSceneSettings.lighting.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 20c8488ac153b4f45944c2d7c85a094e
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 4890085278179872738
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Unity.Mathematics.TestProject/Packages/manifest.json b/Unity.Mathematics.TestProject/Packages/manifest.json
index 5b27463f..e40c4a4b 100644
--- a/Unity.Mathematics.TestProject/Packages/manifest.json
+++ b/Unity.Mathematics.TestProject/Packages/manifest.json
@@ -1,12 +1,14 @@
 {
   "dependencies": {
-    "com.unity.burst": "1.2.3",
-    "com.unity.ide.rider": "1.1.4",
-    "com.unity.ide.vscode": "1.1.4",
+    "com.unity.ai.navigation": "1.1.4",
+    "com.unity.burst": "1.8.7",
+    "com.unity.ide.rider": "3.0.24",
+    "com.unity.ide.visualstudio": "2.0.18",
+    "com.unity.ide.vscode": "1.2.5",
     "com.unity.mathematics": "file:../../src",
     "com.unity.package-validation-suite": "0.8.1-preview",
-    "com.unity.properties": "0.10.4-preview",
-    "com.unity.test-framework": "1.1.11",
+    "com.unity.properties": "2.1.0-exp.3",
+    "com.unity.test-framework": "1.1.33",
     "com.unity.test-framework.performance": "2.8.0-preview"
   },
   "testables": [
diff --git a/Unity.Mathematics.TestProject/ProjectSettings/EditorBuildSettings.asset b/Unity.Mathematics.TestProject/ProjectSettings/EditorBuildSettings.asset
index 0147887e..40917b05 100644
--- a/Unity.Mathematics.TestProject/ProjectSettings/EditorBuildSettings.asset
+++ b/Unity.Mathematics.TestProject/ProjectSettings/EditorBuildSettings.asset
@@ -4,5 +4,8 @@
 EditorBuildSettings:
   m_ObjectHideFlags: 0
   serializedVersion: 2
-  m_Scenes: []
+  m_Scenes:
+  - enabled: 1
+    path: Assets/Scenes/SampleScene.unity
+    guid: 9fc0d4010bbf28b4594072e72b8655ab
   m_configObjects: {}
diff --git a/Unity.Mathematics.TestProject/ProjectSettings/GraphicsSettings.asset b/Unity.Mathematics.TestProject/ProjectSettings/GraphicsSettings.asset
index 35a0fa7f..bea55798 100644
--- a/Unity.Mathematics.TestProject/ProjectSettings/GraphicsSettings.asset
+++ b/Unity.Mathematics.TestProject/ProjectSettings/GraphicsSettings.asset
@@ -36,6 +36,10 @@ GraphicsSettings:
   - {fileID: 10753, guid: 0000000000000000f000000000000000, type: 0}
   - {fileID: 10770, guid: 0000000000000000f000000000000000, type: 0}
   - {fileID: 10783, guid: 0000000000000000f000000000000000, type: 0}
+  - {fileID: 16000, guid: 0000000000000000f000000000000000, type: 0}
+  - {fileID: 16001, guid: 0000000000000000f000000000000000, type: 0}
+  - {fileID: 16003, guid: 0000000000000000f000000000000000, type: 0}
+  - {fileID: 17000, guid: 0000000000000000f000000000000000, type: 0}
   m_PreloadedShaders: []
   m_SpritesDefaultMaterial: {fileID: 10754, guid: 0000000000000000f000000000000000,
     type: 0}
diff --git a/Unity.Mathematics.TestProject/ProjectSettings/ProjectSettings.asset b/Unity.Mathematics.TestProject/ProjectSettings/ProjectSettings.asset
index f8345c9f..9eb3e0b5 100644
--- a/Unity.Mathematics.TestProject/ProjectSettings/ProjectSettings.asset
+++ b/Unity.Mathematics.TestProject/ProjectSettings/ProjectSettings.asset
@@ -3,7 +3,7 @@
 --- !u!129 &1
 PlayerSettings:
   m_ObjectHideFlags: 0
-  serializedVersion: 20
+  serializedVersion: 26
   productGUID: 50c0163089a174a7ab9f46f0020a809f
   AndroidProfiler: 0
   AndroidFilterTouchesWhenObscured: 0
@@ -48,12 +48,15 @@ PlayerSettings:
   defaultScreenHeightWeb: 600
   m_StereoRenderingPath: 0
   m_ActiveColorSpace: 0
+  m_SpriteBatchVertexThreshold: 300
   m_MTRendering: 1
+  mipStripping: 0
+  numberOfMipsStripped: 0
+  numberOfMipsStrippedPerMipmapLimitGroup: {}
   m_StackTraceTypes: 010000000100000001000000010000000100000001000000
   iosShowActivityIndicatorOnLoading: -1
   androidShowActivityIndicatorOnLoading: -1
   iosUseCustomAppBackgroundBehavior: 0
-  iosAllowHTTPDownload: 1
   allowedAutorotateToPortrait: 1
   allowedAutorotateToPortraitUpsideDown: 1
   allowedAutorotateToLandscapeRight: 1
@@ -66,6 +69,12 @@ PlayerSettings:
   androidRenderOutsideSafeArea: 1
   androidUseSwappy: 0
   androidBlitType: 0
+  androidResizableWindow: 0
+  androidDefaultWindowWidth: 1920
+  androidDefaultWindowHeight: 1080
+  androidMinimumWindowWidth: 400
+  androidMinimumWindowHeight: 300
+  androidFullscreenMode: 1
   defaultIsNativeResolution: 1
   macRetinaSupport: 1
   runInBackground: 1
@@ -103,6 +112,7 @@ PlayerSettings:
   xboxOneMonoLoggingLevel: 0
   xboxOneLoggingLevel: 1
   xboxOneDisableEsram: 0
+  xboxOneEnableTypeOptimization: 0
   xboxOnePresentImmediateThreshold: 0
   switchQueueCommandMemory: 0
   switchQueueControlMemory: 16384
@@ -110,14 +120,19 @@ PlayerSettings:
   switchNVNShaderPoolsGranularity: 33554432
   switchNVNDefaultPoolsGranularity: 16777216
   switchNVNOtherPoolsGranularity: 16777216
+  switchGpuScratchPoolGranularity: 2097152
+  switchAllowGpuScratchShrinking: 0
+  switchNVNMaxPublicTextureIDCount: 0
+  switchNVNMaxPublicSamplerIDCount: 0
+  switchNVNGraphicsFirmwareMemory: 32
+  stadiaPresentMode: 0
+  stadiaTargetFramerate: 0
   vulkanNumSwapchainBuffers: 3
   vulkanEnableSetSRGBWrite: 0
-  m_SupportedAspectRatios:
-    4:3: 1
-    5:4: 1
-    16:10: 1
-    16:9: 1
-    Others: 1
+  vulkanEnablePreTransform: 0
+  vulkanEnableLateAcquireNextImage: 0
+  vulkanEnableCommandBufferRecycling: 1
+  loadStoreDebugModeEnabled: 0
   bundleVersion: 0.1
   preloadedAssets: []
   metroInputSource: 0
@@ -126,45 +141,28 @@ PlayerSettings:
   xboxOneDisableKinectGpuReservation: 0
   xboxOneEnable7thCore: 0
   vrSettings:
-    cardboard:
-      depthFormat: 0
-      enableTransitionView: 0
-    daydream:
-      depthFormat: 0
-      useSustainedPerformanceMode: 0
-      enableVideoLayer: 0
-      useProtectedVideoMemory: 0
-      minimumSupportedHeadTracking: 0
-      maximumSupportedHeadTracking: 1
-    hololens:
-      depthFormat: 1
-      depthBufferSharingEnabled: 0
-    lumin:
-      depthFormat: 0
-      frameTiming: 2
-      enableGLCache: 0
-      glCacheMaxBlobSize: 524288
-      glCacheMaxFileSize: 8388608
-    oculus:
-      sharedDepthBuffer: 1
-      dashSupport: 1
-      lowOverheadMode: 0
-      protectedContext: 0
-      v2Signing: 1
     enable360StereoCapture: 0
   isWsaHolographicRemotingEnabled: 0
   enableFrameTimingStats: 0
+  enableOpenGLProfilerGPURecorders: 1
   useHDRDisplay: 0
-  D3DHDRBitDepth: 0
+  hdrBitDepth: 0
   m_ColorGamuts: 00000000
   targetPixelDensity: 30
   resolutionScalingMode: 0
+  resetResolutionOnWindowResize: 0
   androidSupportedAspectRatio: 1
   androidMaxAspectRatio: 2.1
-  applicationIdentifier: {}
-  buildNumber: {}
+  applicationIdentifier:
+    Android: com.UnityTestRunner.UnityTestRunner
+  buildNumber:
+    Standalone: 0
+    VisionOS: 0
+    iPhone: 0
+    tvOS: 0
+  overrideDefaultApplicationIdentifier: 1
   AndroidBundleVersionCode: 1
-  AndroidMinSdkVersion: 19
+  AndroidMinSdkVersion: 22
   AndroidTargetSdkVersion: 0
   AndroidPreferredInstallLocation: 1
   aotOptions: 
@@ -177,34 +175,21 @@ PlayerSettings:
   APKExpansionFiles: 0
   keepLoadedShadersAlive: 0
   StripUnusedMeshComponents: 1
+  strictShaderVariantMatching: 0
   VertexChannelCompressionMask: 4054
   iPhoneSdkVersion: 988
-  iOSTargetOSVersionString: 10.0
+  iOSTargetOSVersionString: 12.0
   tvOSSdkVersion: 0
   tvOSRequireExtendedGameController: 0
-  tvOSTargetOSVersionString: 10.0
+  tvOSTargetOSVersionString: 12.0
+  VisionOSSdkVersion: 0
+  VisionOSTargetOSVersionString: 1.0
   uIPrerenderedIcon: 0
   uIRequiresPersistentWiFi: 0
   uIRequiresFullScreen: 1
   uIStatusBarHidden: 1
   uIExitOnSuspend: 0
   uIStatusBarStyle: 0
-  iPhoneSplashScreen: {fileID: 0}
-  iPhoneHighResSplashScreen: {fileID: 0}
-  iPhoneTallHighResSplashScreen: {fileID: 0}
-  iPhone47inSplashScreen: {fileID: 0}
-  iPhone55inPortraitSplashScreen: {fileID: 0}
-  iPhone55inLandscapeSplashScreen: {fileID: 0}
-  iPhone58inPortraitSplashScreen: {fileID: 0}
-  iPhone58inLandscapeSplashScreen: {fileID: 0}
-  iPadPortraitSplashScreen: {fileID: 0}
-  iPadHighResPortraitSplashScreen: {fileID: 0}
-  iPadLandscapeSplashScreen: {fileID: 0}
-  iPadHighResLandscapeSplashScreen: {fileID: 0}
-  iPhone65inPortraitSplashScreen: {fileID: 0}
-  iPhone65inLandscapeSplashScreen: {fileID: 0}
-  iPhone61inPortraitSplashScreen: {fileID: 0}
-  iPhone61inLandscapeSplashScreen: {fileID: 0}
   appleTVSplashScreen: {fileID: 0}
   appleTVSplashScreen2x: {fileID: 0}
   tvOSSmallIconLayers: []
@@ -232,32 +217,47 @@ PlayerSettings:
   iOSLaunchScreeniPadFillPct: 100
   iOSLaunchScreeniPadSize: 100
   iOSLaunchScreeniPadCustomXibPath: 
-  iOSUseLaunchScreenStoryboard: 0
   iOSLaunchScreenCustomStoryboardPath: 
+  iOSLaunchScreeniPadCustomStoryboardPath: 
   iOSDeviceRequirements: []
   iOSURLSchemes: []
+  macOSURLSchemes: []
   iOSBackgroundModes: 0
   iOSMetalForceHardShadows: 0
   metalEditorSupport: 1
   metalAPIValidation: 1
   iOSRenderExtraFrameOnPause: 0
+  iosCopyPluginsCodeInsteadOfSymlink: 0
   appleDeveloperTeamID: 
   iOSManualSigningProvisioningProfileID: 
   tvOSManualSigningProvisioningProfileID: 
+  VisionOSManualSigningProvisioningProfileID: 
   iOSManualSigningProvisioningProfileType: 0
   tvOSManualSigningProvisioningProfileType: 0
+  VisionOSManualSigningProvisioningProfileType: 0
   appleEnableAutomaticSigning: 0
   iOSRequireARKit: 0
   iOSAutomaticallyDetectAndAddCapabilities: 1
   appleEnableProMotion: 0
+  shaderPrecisionModel: 0
   clonedFromGUID: c0afd0d1d80e3634a9dac47e8a0426ea
   templatePackageId: com.unity.template.3d@1.0.11
   templateDefaultScene: Assets/Scenes/SampleScene.unity
+  useCustomMainManifest: 0
+  useCustomLauncherManifest: 0
+  useCustomMainGradleTemplate: 0
+  useCustomLauncherGradleManifest: 0
+  useCustomBaseGradleTemplate: 0
+  useCustomGradlePropertiesTemplate: 0
+  useCustomGradleSettingsTemplate: 0
+  useCustomProguardFile: 0
   AndroidTargetArchitectures: 1
+  AndroidTargetDevices: 0
   AndroidSplashScreenScale: 0
   androidSplashScreen: {fileID: 0}
   AndroidKeystoreName: '{inproject}: '
   AndroidKeyaliasName: 
+  AndroidEnableArmv9SecurityFeatures: 0
   AndroidBuildApkPerCpuArchitecture: 0
   AndroidTVCompatibility: 0
   AndroidIsGame: 1
@@ -270,10 +270,105 @@ PlayerSettings:
     height: 180
     banner: {fileID: 0}
   androidGamepadSupportLevel: 0
+  chromeosInputEmulation: 1
+  AndroidMinifyRelease: 0
+  AndroidMinifyDebug: 0
   AndroidValidateAppBundleSize: 1
   AndroidAppBundleSizeToValidate: 100
   m_BuildTargetIcons: []
-  m_BuildTargetPlatformIcons: []
+  m_BuildTargetPlatformIcons:
+  - m_BuildTarget: Android
+    m_Icons:
+    - m_Textures: []
+      m_Width: 432
+      m_Height: 432
+      m_Kind: 2
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 324
+      m_Height: 324
+      m_Kind: 2
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 216
+      m_Height: 216
+      m_Kind: 2
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 162
+      m_Height: 162
+      m_Kind: 2
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 108
+      m_Height: 108
+      m_Kind: 2
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 81
+      m_Height: 81
+      m_Kind: 2
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 192
+      m_Height: 192
+      m_Kind: 0
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 144
+      m_Height: 144
+      m_Kind: 0
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 96
+      m_Height: 96
+      m_Kind: 0
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 72
+      m_Height: 72
+      m_Kind: 0
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 48
+      m_Height: 48
+      m_Kind: 0
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 36
+      m_Height: 36
+      m_Kind: 0
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 192
+      m_Height: 192
+      m_Kind: 1
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 144
+      m_Height: 144
+      m_Kind: 1
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 96
+      m_Height: 96
+      m_Kind: 1
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 72
+      m_Height: 72
+      m_Kind: 1
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 48
+      m_Height: 48
+      m_Kind: 1
+      m_SubKind: 
+    - m_Textures: []
+      m_Width: 36
+      m_Height: 36
+      m_Kind: 1
+      m_SubKind: 
   m_BuildTargetBatching:
   - m_BuildTarget: Standalone
     m_StaticBatching: 1
@@ -290,6 +385,7 @@ PlayerSettings:
   - m_BuildTarget: WebGL
     m_StaticBatching: 0
     m_DynamicBatching: 0
+  m_BuildTargetShaderSettings: []
   m_BuildTargetGraphicsJobs:
   - m_BuildTarget: MacStandaloneSupport
     m_GraphicsJobs: 0
@@ -325,13 +421,13 @@ PlayerSettings:
   m_BuildTargetGraphicsAPIs:
   - m_BuildTarget: AndroidPlayer
     m_APIs: 150000000b000000
-    m_Automatic: 0
+    m_Automatic: 1
   - m_BuildTarget: iOSSupport
     m_APIs: 10000000
     m_Automatic: 1
   - m_BuildTarget: AppleTVSupport
     m_APIs: 10000000
-    m_Automatic: 0
+    m_Automatic: 1
   - m_BuildTarget: WebGLSupport
     m_APIs: 0b000000
     m_Automatic: 1
@@ -341,6 +437,8 @@ PlayerSettings:
     m_Devices:
     - Oculus
     - OpenVR
+  m_DefaultShaderChunkSizeInMB: 16
+  m_DefaultShaderChunkCount: 0
   openGLRequireES31: 0
   openGLRequireES31AEP: 0
   openGLRequireES32: 0
@@ -350,7 +448,11 @@ PlayerSettings:
     iPhone: 1
     tvOS: 1
   m_BuildTargetGroupLightmapEncodingQuality: []
+  m_BuildTargetGroupHDRCubemapEncodingQuality: []
   m_BuildTargetGroupLightmapSettings: []
+  m_BuildTargetGroupLoadStoreDebugModeSettings: []
+  m_BuildTargetNormalMapEncoding: []
+  m_BuildTargetDefaultTextureCompressionFormat: []
   playModeTestRunnerEnabled: 0
   runPlayModeTestAsEditModeTest: 0
   actionOnDotNetUnhandledException: 1
@@ -360,14 +462,20 @@ PlayerSettings:
   cameraUsageDescription: 
   locationUsageDescription: 
   microphoneUsageDescription: 
+  bluetoothUsageDescription: 
+  macOSTargetOSVersion: 10.13.0
+  switchNMETAOverride: 
   switchNetLibKey: 
   switchSocketMemoryPoolSize: 6144
   switchSocketAllocatorPoolSize: 128
   switchSocketConcurrencyLimit: 14
   switchScreenResolutionBehavior: 2
   switchUseCPUProfiler: 0
+  switchUseGOLDLinker: 0
+  switchLTOSetting: 0
   switchApplicationID: 0x01004b9000490000
   switchNSODependencies: 
+  switchCompilerFlags: 
   switchTitleNames_0: 
   switchTitleNames_1: 
   switchTitleNames_2: 
@@ -383,6 +491,7 @@ PlayerSettings:
   switchTitleNames_12: 
   switchTitleNames_13: 
   switchTitleNames_14: 
+  switchTitleNames_15: 
   switchPublisherNames_0: 
   switchPublisherNames_1: 
   switchPublisherNames_2: 
@@ -398,6 +507,7 @@ PlayerSettings:
   switchPublisherNames_12: 
   switchPublisherNames_13: 
   switchPublisherNames_14: 
+  switchPublisherNames_15: 
   switchIcons_0: {fileID: 0}
   switchIcons_1: {fileID: 0}
   switchIcons_2: {fileID: 0}
@@ -413,6 +523,7 @@ PlayerSettings:
   switchIcons_12: {fileID: 0}
   switchIcons_13: {fileID: 0}
   switchIcons_14: {fileID: 0}
+  switchIcons_15: {fileID: 0}
   switchSmallIcons_0: {fileID: 0}
   switchSmallIcons_1: {fileID: 0}
   switchSmallIcons_2: {fileID: 0}
@@ -428,6 +539,7 @@ PlayerSettings:
   switchSmallIcons_12: {fileID: 0}
   switchSmallIcons_13: {fileID: 0}
   switchSmallIcons_14: {fileID: 0}
+  switchSmallIcons_15: {fileID: 0}
   switchManualHTML: 
   switchAccessibleURLs: 
   switchLegalInformation: 
@@ -437,7 +549,6 @@ PlayerSettings:
   switchReleaseVersion: 0
   switchDisplayVersion: 1.0.0
   switchStartupUserAccount: 0
-  switchTouchScreenUsage: 0
   switchSupportedLanguagesMask: 0
   switchLogoType: 0
   switchApplicationErrorCodeCategory: 
@@ -479,6 +590,7 @@ PlayerSettings:
   switchNativeFsCacheSize: 32
   switchIsHoldTypeHorizontal: 0
   switchSupportedNpadCount: 8
+  switchEnableTouchScreen: 1
   switchSocketConfigEnabled: 0
   switchTcpInitialSendBufferSize: 32
   switchTcpInitialReceiveBufferSize: 64
@@ -490,6 +602,12 @@ PlayerSettings:
   switchSocketInitializeEnabled: 1
   switchNetworkInterfaceManagerInitializeEnabled: 1
   switchPlayerConnectionEnabled: 1
+  switchUseNewStyleFilepaths: 1
+  switchUseLegacyFmodPriorities: 0
+  switchUseMicroSleepForYield: 1
+  switchEnableRamDiskSupport: 0
+  switchMicroSleepForYieldTime: 25
+  switchRamDiskSpaceSize: 12
   ps4NPAgeRating: 12
   ps4NPTitleSecret: 
   ps4NPTrophyPackPath: 
@@ -516,6 +634,7 @@ PlayerSettings:
   ps4ShareFilePath: 
   ps4ShareOverlayImagePath: 
   ps4PrivacyGuardImagePath: 
+  ps4ExtraSceSysFile: 
   ps4NPtitleDatPath: 
   ps4RemotePlayKeyAssignment: -1
   ps4RemotePlayKeyMappingDir: 
@@ -541,6 +660,7 @@ PlayerSettings:
   ps4UseResolutionFallback: 0
   ps4ReprojectionSupport: 0
   ps4UseAudio3dBackend: 0
+  ps4UseLowGarlicFragmentationMode: 1
   ps4SocialScreenEnabled: 0
   ps4ScriptOptimizationLevel: 0
   ps4Audio3dVirtualSpeakerCount: 14
@@ -557,6 +677,9 @@ PlayerSettings:
   ps4disableAutoHideSplash: 0
   ps4videoRecordingFeaturesUsed: 0
   ps4contentSearchFeaturesUsed: 0
+  ps4CompatibilityPS5: 0
+  ps4AllowPS5Detection: 0
+  ps4GPU800MHz: 1
   ps4attribEyeToEyeDistanceSettingVR: 0
   ps4IncludedModules: []
   ps4attribVROutputEnabled: 0
@@ -568,6 +691,7 @@ PlayerSettings:
   webGLMemorySize: 16
   webGLExceptionSupport: 1
   webGLNameFilesAsHashes: 0
+  webGLShowDiagnostics: 0
   webGLDataCaching: 1
   webGLDebugSymbols: 0
   webGLEmscriptenArgs: 
@@ -576,16 +700,45 @@ PlayerSettings:
   webGLAnalyzeBuildSize: 0
   webGLUseEmbeddedResources: 0
   webGLCompressionFormat: 1
+  webGLWasmArithmeticExceptions: 0
   webGLLinkerTarget: 1
   webGLThreadsSupport: 0
-  webGLWasmStreaming: 0
+  webGLDecompressionFallback: 0
+  webGLInitialMemorySize: 32
+  webGLMaximumMemorySize: 2048
+  webGLMemoryGrowthMode: 2
+  webGLMemoryLinearGrowthStep: 16
+  webGLMemoryGeometricGrowthStep: 0.2
+  webGLMemoryGeometricGrowthCap: 96
+  webGLPowerPreference: 2
   scriptingDefineSymbols: {}
+  additionalCompilerArguments: {}
   platformArchitecture: {}
-  scriptingBackend: {}
+  scriptingBackend:
+    Android: 1
+    Standalone: 1
   il2cppCompilerConfiguration: {}
-  managedStrippingLevel: {}
+  il2cppCodeGeneration: {}
+  managedStrippingLevel:
+    Android: 1
+    EmbeddedLinux: 1
+    GameCoreScarlett: 1
+    GameCoreXboxOne: 1
+    Nintendo Switch: 1
+    PS4: 1
+    PS5: 1
+    QNX: 1
+    Stadia: 1
+    VisionOS: 1
+    WebGL: 1
+    Windows Store Apps: 1
+    XboxOne: 1
+    iPhone: 1
+    tvOS: 1
   incrementalIl2cppBuild: {}
-  allowUnsafeCode: 0
+  suppressCommonWarnings: 1
+  allowUnsafeCode: 1
+  useDeterministicCompilation: 1
   additionalIl2CppArgs: 
   scriptingRuntimeVersion: 1
   gcIncremental: 0
@@ -620,6 +773,7 @@ PlayerSettings:
   metroFTAName: 
   metroFTAFileTypes: []
   metroProtocolName: 
+  vcxProjDefaultLanguage: 
   XboxOneProductId: 
   XboxOneUpdateKey: 
   XboxOneSandboxId: 
@@ -638,6 +792,7 @@ PlayerSettings:
   XboxOneCapability: []
   XboxOneGameRating: {}
   XboxOneIsContentPackage: 0
+  XboxOneEnhancedXboxCompatibilityMode: 0
   XboxOneEnableGPUVariability: 0
   XboxOneSockets: {}
   XboxOneSplashScreen: {fileID: 0}
@@ -645,10 +800,8 @@ PlayerSettings:
   XboxOnePersistentLocalStorageSize: 0
   XboxOneXTitleMemory: 8
   XboxOneOverrideIdentityName: 
-  vrEditorSettings:
-    daydream:
-      daydreamIconForeground: {fileID: 0}
-      daydreamIconBackground: {fileID: 0}
+  XboxOneOverrideIdentityPublisher: 
+  vrEditorSettings: {}
   cloudServicesEnabled:
     UNet: 1
   luminIcon:
@@ -662,12 +815,22 @@ PlayerSettings:
   luminVersion:
     m_VersionCode: 1
     m_VersionName: 
+  hmiPlayerDataPath: 
+  hmiForceSRGBBlit: 1
+  embeddedLinuxEnableGamepadInput: 1
+  hmiLogStartupTiming: 0
+  hmiCpuConfiguration: 
   apiCompatibilityLevel: 6
+  activeInputHandler: 0
+  windowsGamepadBackendHint: 0
   cloudProjectId: 
   framebufferDepthMemorylessMode: 0
+  qualitySettingsNames: []
   projectName: 
   organizationId: 
   cloudEnabled: 0
-  enableNativePlatformBackendsForNewInputSystem: 0
-  disableOldInputManagerSupport: 0
   legacyClampBlendShapeWeights: 1
+  hmiLoadingImage: {fileID: 0}
+  platformRequiresReadableAssets: 0
+  virtualTexturingSupportEnabled: 0
+  insecureHttpOption: 0
diff --git a/Unity.Mathematics.TestProject/ProjectSettings/ProjectVersion.txt b/Unity.Mathematics.TestProject/ProjectSettings/ProjectVersion.txt
index 798259ba..78a77889 100644
--- a/Unity.Mathematics.TestProject/ProjectSettings/ProjectVersion.txt
+++ b/Unity.Mathematics.TestProject/ProjectSettings/ProjectVersion.txt
@@ -1,2 +1,2 @@
-m_EditorVersion: 2019.3.0f6
-m_EditorVersionWithRevision: 2019.3.0f6 (27ab2135bccf)
+m_EditorVersion: 2022.3.7f1
+m_EditorVersionWithRevision: 2022.3.7f1 (b16b3b16c7a0)
diff --git a/Unity.Mathematics.TestProject/ProjectSettings/UnityConnectSettings.asset b/Unity.Mathematics.TestProject/ProjectSettings/UnityConnectSettings.asset
index fa0b1465..a88bee0f 100644
--- a/Unity.Mathematics.TestProject/ProjectSettings/UnityConnectSettings.asset
+++ b/Unity.Mathematics.TestProject/ProjectSettings/UnityConnectSettings.asset
@@ -9,6 +9,7 @@ UnityConnectSettings:
   m_EventOldUrl: https://api.uca.cloud.unity3d.com/v1/events
   m_EventUrl: https://cdp.cloud.unity3d.com/v1/events
   m_ConfigUrl: https://config.uca.cloud.unity3d.com
+  m_DashboardUrl: https://dashboard.unity3d.com
   m_TestInitMode: 0
   CrashReportingSettings:
     m_EventUrl: https://perf-events.cloud.unity3d.com
@@ -22,6 +23,7 @@ UnityConnectSettings:
     m_Enabled: 0
     m_TestMode: 0
     m_InitializeOnStartup: 1
+    m_PackageRequiringCoreStatsPresent: 0
   UnityAdsSettings:
     m_Enabled: 0
     m_InitializeOnStartup: 1
diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index 4a2f3065..8367c2b0 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -6,7 +6,7 @@
 ### Deprecated
 ### Removed
 ### Fixed
-
+* Fixed `math.hash` crash when using IL2CPP builds on Arm 32 bit devices.
 
 ## [1.3.0] 2023-07-12
 
diff --git a/src/Tests/Tests/Shared/TestAffineTransform.cs b/src/Tests/Tests/Shared/TestAffineTransform.cs
index a5b31efe..77af61f8 100644
--- a/src/Tests/Tests/Shared/TestAffineTransform.cs
+++ b/src/Tests/Tests/Shared/TestAffineTransform.cs
@@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     class TestAffineTransform
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void affine_transform_construct_from_float3x3()
         {
             const float tolerance = 1e-6f;
@@ -20,7 +20,7 @@ public static void affine_transform_construct_from_float3x3()
             TestUtils.AreEqual(m3x3, testM3x3, tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void affine_transform_construct_from_float3x4()
         {
             const float tolerance = 1e-6f;
@@ -33,7 +33,7 @@ public static void affine_transform_construct_from_float3x4()
             TestUtils.AreEqual(m3x4, testM3x4, tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void affine_transform_construct_from_float4x4()
         {
             const float tolerance = 1e-6f;
@@ -46,7 +46,7 @@ public static void affine_transform_construct_from_float4x4()
             TestUtils.AreEqual(m4x4, testM4x4, tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void affine_transform_construct_from_RigidTransform()
         {
             const float tolerance = 1e-6f;
@@ -58,7 +58,7 @@ public static void affine_transform_construct_from_RigidTransform()
             TestUtils.AreEqual(r.pos, tx.t, tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void affine_transform_inverse()
         {
             const float tolerance = 1e-6f;
@@ -69,7 +69,7 @@ public static void affine_transform_inverse()
             TestUtils.AreEqual(float4x4.identity, mul(tx, invTx), tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void affine_transform_inverse_zero_rs_returns_zero()
         {
             const float tolerance = 1e-30f;
@@ -80,7 +80,7 @@ public static void affine_transform_inverse_zero_rs_returns_zero()
             TestUtils.AreEqual(float3x4.zero, invTx, tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void affine_transform_inverse_pico_scale()
         {
             // slightly larger tolerance (vs 1e-6f) for PS4
@@ -92,7 +92,7 @@ public static void affine_transform_inverse_pico_scale()
             TestUtils.AreEqual(float4x4.identity, mul(tx, invTx), tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void affine_transform_inverse_singular()
         {
             // it needs a bit larger tolerance for singular
@@ -107,7 +107,7 @@ public static void affine_transform_inverse_singular()
             TestUtils.AreEqual(float4x4(tx), float4x4(testTx), tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void affine_transform_decompose()
         {
             const float tolerance = 1e-6f;
@@ -120,7 +120,7 @@ public static void affine_transform_decompose()
             TestUtils.AreEqual(float4x4(tx), float4x4(testTx), tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void affine_transform_mul_vector()
         {
             float4x4 m = TestMatrix.test4x4_xyz;
@@ -137,7 +137,7 @@ public static void affine_transform_mul_vector()
             TestUtils.AreEqual(mvector1, txvector1, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void affine_transform_rotate_vector()
         {
             float3x3 m = TestMatrix.test3x3_xyz;
@@ -150,7 +150,7 @@ public static void affine_transform_rotate_vector()
             TestUtils.AreEqual(mvector0, txvector0, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void affine_transform_transform_point()
         {
             float4x4 m = float4x4(TestMatrix.test3x3_zyx, float3(1f, 2f, 3f));
@@ -163,7 +163,7 @@ public static void affine_transform_transform_point()
             TestUtils.AreEqual(mPt0, txPt0, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void affine_transform_zero()
         {
             TestUtils.AreEqual(float3x3.zero, AffineTransform.zero.rs);
diff --git a/src/Tests/Tests/Shared/TestBitmanipulation.cs b/src/Tests/Tests/Shared/TestBitmanipulation.cs
index 517d8d67..e3c91791 100644
--- a/src/Tests/Tests/Shared/TestBitmanipulation.cs
+++ b/src/Tests/Tests/Shared/TestBitmanipulation.cs
@@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBitmanipulation
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bitmask_bool4()
         {
             TestUtils.AreEqual(bitmask(new bool4(false, false, false, false)), 0b0000);
@@ -23,7 +23,7 @@ public static void bitmask_bool4()
             TestUtils.AreEqual(bitmask(new bool4(true, true, true, false)), 0b0111);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void countbits_int1()
         {
             TestUtils.AreEqual(12, countbits( 0x01234567));
@@ -33,7 +33,7 @@ public static void countbits_int1()
             TestUtils.AreEqual(32, countbits(-1));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void countbits_int2()
         {
             TestUtils.AreEqual(int2(0, 12), countbits(int2(0, 0x01234567)));
@@ -41,21 +41,21 @@ public static void countbits_int2()
             TestUtils.AreEqual(int2(17, 32), countbits(int2(-0x456789AB, -1)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void countbits_int3()
         {
             TestUtils.AreEqual(int3(0, 12, 16), countbits(int3(0, 0x01234567, 0x456789AB)));
             TestUtils.AreEqual(int3(21, 17, 32), countbits(int3(-0x01234567, -0x456789AB, -1)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void countbits_int4()
         {
             TestUtils.AreEqual(int4(0, 12, 16, 21), countbits(int4(0, 0x01234567, 0x456789AB, -0x01234567)));
             TestUtils.AreEqual(int4(17, 32, 30, 29), countbits(int4(-0x456789AB, -1, -7, -15)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void countbits_uint()
         {
             TestUtils.AreEqual(0, countbits(0u));
@@ -66,7 +66,7 @@ public static void countbits_uint()
             TestUtils.AreEqual(32, countbits(0xFFFFFFFFu));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void countbits_uint2()
         {
             TestUtils.AreEqual(int2(0, 12), countbits(uint2(0, 0x01234567)));
@@ -74,21 +74,21 @@ public static void countbits_uint2()
             TestUtils.AreEqual(int2(16, 32), countbits(uint2(0xCDEF0123u, 0xFFFFFFFFu)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void countbits_uint3()
         {
             TestUtils.AreEqual(int3(0, 12, 16), countbits(uint3(0, 0x01234567, 0x456789AB)));
             TestUtils.AreEqual(int3(20, 16, 32), countbits(uint3(0x89ABCDEFu, 0xCDEF0123u, 0xFFFFFFFFu)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void countbits_uint4()
         {
             TestUtils.AreEqual(int4(0, 12, 16, 20), countbits(uint4(0, 0x01234567, 0x456789AB, 0x89ABCDEFu)));
             TestUtils.AreEqual(int4(16, 32, 30, 29), countbits(uint4(0xCDEF0123u, 0xFFFFFFFFu, 0xFFFFFFF5u, 0xFFFFFFF1u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void countbits_long()
         {
             TestUtils.AreEqual(0, countbits(0L));
@@ -97,7 +97,7 @@ public static void countbits_long()
             TestUtils.AreEqual(64, countbits(-1L));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void countbits_ulong()
         {
             TestUtils.AreEqual(0, countbits(0UL));
@@ -106,7 +106,7 @@ public static void countbits_ulong()
             TestUtils.AreEqual(64, countbits(0xFFFFFFFFFFFFFFFFUL));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lzcnt_int()
         {
             TestUtils.AreEqual(32, lzcnt(0));
@@ -119,7 +119,7 @@ public static void lzcnt_int()
             TestUtils.AreEqual(0, lzcnt(-2147483648));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lzcnt_int2()
         {
             TestUtils.AreEqual(int2(32, 31), lzcnt(int2(0, 1)));
@@ -128,7 +128,7 @@ public static void lzcnt_int2()
             TestUtils.AreEqual(int2(0, 0), lzcnt(int2(-1, -2147483648)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lzcnt_int3()
         {
             TestUtils.AreEqual(int3(32, 31, 30), lzcnt(int3(0, 1, 2)));
@@ -136,14 +136,14 @@ public static void lzcnt_int3()
             TestUtils.AreEqual(int3(0, 0, 27), lzcnt(int3(-1, -2147483648, 17)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lzcnt_int4()
         {
             TestUtils.AreEqual(int4(32, 31, 30, 30), lzcnt(int4(0, 1, 2, 3)));
             TestUtils.AreEqual(int4(17, 5, 0, 0), lzcnt(int4(0x5321, 0x04435321, -1, -2147483648)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lzcnt_uint()
         {
             TestUtils.AreEqual(32, lzcnt(0u));
@@ -156,7 +156,7 @@ public static void lzcnt_uint()
             TestUtils.AreEqual(0, lzcnt(0xFFFFFFFFu));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lzcnt_uint2()
         {
             TestUtils.AreEqual(int2(32, 31), lzcnt(uint2(0u, 1u)));
@@ -165,7 +165,7 @@ public static void lzcnt_uint2()
             TestUtils.AreEqual(int2(0, 0), lzcnt(uint2(0x84435320u, 0xFFFFFFFFu)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lzcnt_uint3()
         {
             TestUtils.AreEqual(int3(32, 31, 30), lzcnt(uint3(0u, 1u, 2u)));
@@ -173,7 +173,7 @@ public static void lzcnt_uint3()
             TestUtils.AreEqual(int3(0, 0, 27), lzcnt(uint3(0x84435320u, 0xFFFFFFFFu, 17)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lzcnt_uint4()
         {
             TestUtils.AreEqual(int2(32, 31), lzcnt(uint2(0u, 1u)));
@@ -182,7 +182,7 @@ public static void lzcnt_uint4()
             TestUtils.AreEqual(int2(0, 0), lzcnt(uint2(0x84435320u, 0xFFFFFFFFu)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lzcnt_long()
         {
             TestUtils.AreEqual(64, lzcnt(0L));
@@ -194,7 +194,7 @@ public static void lzcnt_long()
             TestUtils.AreEqual(0, lzcnt(-9223372036854775808L));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lzcnt_ulong()
         {
             TestUtils.AreEqual(64, lzcnt(0UL));
@@ -206,7 +206,7 @@ public static void lzcnt_ulong()
             TestUtils.AreEqual(0, lzcnt(0x8000000000000000UL));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tzcnt_int()
         {
             TestUtils.AreEqual(32, tzcnt(0));
@@ -220,7 +220,7 @@ public static void tzcnt_int()
             TestUtils.AreEqual(31, tzcnt(-2147483648));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tzcnt_int2()
         {
             TestUtils.AreEqual(int2(32, 0), tzcnt(int2(0, 1)));
@@ -230,7 +230,7 @@ public static void tzcnt_int2()
             TestUtils.AreEqual(int2(31, 2), tzcnt(int2(-2147483648, 20)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tzcnt_int3()
         {
             TestUtils.AreEqual(int3(32, 0, 1), tzcnt(int3(0, 1, 2)));
@@ -238,7 +238,7 @@ public static void tzcnt_int3()
             TestUtils.AreEqual(int3(1, 0, 31), tzcnt(int3(-2, -2147483647, -2147483648)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tzcnt_int4()
         {
             TestUtils.AreEqual(int4(32, 0, 1, 0), tzcnt(int4(0, 1, 2, 3)));
@@ -246,7 +246,7 @@ public static void tzcnt_int4()
             TestUtils.AreEqual(int4(31, 2, 2, 3), tzcnt(int4(-2147483648, 20, 4132, -8)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tzcnt_uint()
         {
             TestUtils.AreEqual(32, tzcnt(0u));
@@ -260,7 +260,7 @@ public static void tzcnt_uint()
             TestUtils.AreEqual(31, tzcnt(0x80000000u));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tzcnt_uint2()
         {
             TestUtils.AreEqual(int2(32, 0), tzcnt(uint2(0u, 1u)));
@@ -270,7 +270,7 @@ public static void tzcnt_uint2()
             TestUtils.AreEqual(int2(31, 2), tzcnt(uint2(0x80000000u, 20u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tzcnt_uint3()
         {
             TestUtils.AreEqual(int3(32, 0, 1), tzcnt(uint3(0u, 1u, 2u)));
@@ -278,7 +278,7 @@ public static void tzcnt_uint3()
             TestUtils.AreEqual(int3(1, 0, 31), tzcnt(uint3(0xFFFFFFFEu, 0x80000001u, 0x80000000u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tzcnt_uint4()
         {
             TestUtils.AreEqual(int4(32, 0, 1, 0), tzcnt(uint4(0u, 1u, 2u, 3u)));
@@ -286,7 +286,7 @@ public static void tzcnt_uint4()
             TestUtils.AreEqual(int4(31, 2, 2, 3), tzcnt(uint4(0x80000000u, 20u, 4132u, 0xFFFFFFF8u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tzcnt_long()
         {
             TestUtils.AreEqual(64, tzcnt(0L));
@@ -298,7 +298,7 @@ public static void tzcnt_long()
             TestUtils.AreEqual(0, tzcnt(-9223372036854775807L));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tzcnt_ulong()
         {
             TestUtils.AreEqual(64, tzcnt(0UL));
@@ -310,7 +310,7 @@ public static void tzcnt_ulong()
             TestUtils.AreEqual(0, tzcnt(0x8000000000000001UL));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void reversebits_int()
         {
             TestUtils.AreEqual(0x03521609, reversebits(-1872213312));
@@ -319,27 +319,27 @@ public static void reversebits_int()
             TestUtils.AreEqual(0x48d9c42e, reversebits(0x74239b12));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void reversebits_int2()
         {
             TestUtils.AreEqual(int2(0x03521609, 0x5f5b0648), reversebits(int2(-1872213312, 0x1260dafa)));
             TestUtils.AreEqual(int2(0x4bbafd8d, 0x48d9c42e), reversebits(int2(-1312858670, 0x74239b12)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void reversebits_int3()
         {
             TestUtils.AreEqual(int3(0x03521609, 0x5f5b0648, 0x4bbafd8d), reversebits(int3(-1872213312, 0x1260dafa, -1312858670)));
             TestUtils.AreEqual(int3(0x48d9c42e, 0, -1), reversebits(int3(0x74239b12, 0, -1)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void reversebits_int4()
         {
             TestUtils.AreEqual(int4(0x03521609, 0x5f5b0648, 0x4bbafd8d, 0x48d9c42e), reversebits(int4(-1872213312, 0x1260dafa, -1312858670, 0x74239b12)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void reversebits_uint()
         {
             TestUtils.AreEqual(0x03521609u, reversebits(0x90684ac0u));
@@ -348,39 +348,39 @@ public static void reversebits_uint()
             TestUtils.AreEqual(0x48d9c42eu, reversebits(0x74239b12u));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void reversebits_uint2()
         {
             TestUtils.AreEqual(uint2(0x03521609u, 0x5f5b0648u), reversebits(uint2(0x90684ac0u, 0x1260dafau)));
             TestUtils.AreEqual(uint2(0x4bbafd8du, 0x48d9c42eu), reversebits(uint2(0xb1bf5dd2u, 0x74239b12u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void reversebits_uint3()
         {
             TestUtils.AreEqual(uint3(0x03521609u, 0x5f5b0648u, 0x4bbafd8du), reversebits(uint3(0x90684ac0u, 0x1260dafau, 0xb1bf5dd2u)));
             TestUtils.AreEqual(uint3(0x48d9c42eu, 0u, 0xFFFFFFFF), reversebits(uint3(0x74239b12u, 0u, 0xFFFFFFFF)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void reversebits_uint4()
         {
             TestUtils.AreEqual(uint4(0x03521609u, 0x5f5b0648u, 0x4bbafd8du, 0x48d9c42eu), reversebits(uint4(0x90684ac0u, 0x1260dafau, 0xb1bf5dd2u, 0x74239b12u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void reversebits_long()
         {
             TestUtils.AreEqual(0x4bbafd8d5f5b0648L, reversebits(0x1260dafab1bf5dd2L));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void reversebits_ulong()
         {
             TestUtils.AreEqual(0x4bbafd8d5f5b0648ul, reversebits(0x1260dafab1bf5dd2ul));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rol_int()
         {
             TestUtils.AreEqual(-1933184920, rol(219257022, 11));
@@ -389,27 +389,27 @@ public static void rol_int()
             TestUtils.AreEqual(661621977, rol(-1692078607, 11));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rol_int2()
         {
             TestUtils.AreEqual(int2(-1933184920, -2048170741), rol(int2(219257022, -1586446996), 11));
             TestUtils.AreEqual(int2(-1152739462, 661621977), rol(int2(-279484078, -1692078607), 11));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rol_int3()
         {
             TestUtils.AreEqual(int3(-1933184920, -2048170741, -1152739462), rol(int3(219257022, -1586446996, -279484078), 11));
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rol_int4()
         {
             TestUtils.AreEqual(int4(-1933184920, -2048170741, -1152739462, 661621977), rol(int4(219257022, -1586446996, -279484078, -1692078607), 11));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rol_uint()
         {
             TestUtils.AreEqual(2361782376u, rol(219257022u, 11));
@@ -418,27 +418,27 @@ public static void rol_uint()
             TestUtils.AreEqual(661621977u, rol(2602888689u, 11));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rol_uint2()
         {
             TestUtils.AreEqual(uint2(2361782376u, 2246796555u), rol(uint2(219257022u, 2708520300u), 11));
             TestUtils.AreEqual(uint2(3142227834u, 661621977u), rol(uint2(4015483218u, 2602888689u), 11));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rol_uint3()
         {
             TestUtils.AreEqual(uint3(2361782376u, 2246796555u, 3142227834u), rol(uint3(219257022u, 2708520300u, 4015483218u), 11));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rol_uint4()
         {
             TestUtils.AreEqual(uint4(2361782376u, 2246796555u, 3142227834u, 661621977u), rol(uint4(219257022u, 2708520300u, 4015483218u, 2602888689u), 11));
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rol_long()
         {
             TestUtils.AreEqual(4769317691753349395L, rol(6894885722123239465L, 37));
@@ -447,7 +447,7 @@ public static void rol_long()
             TestUtils.AreEqual(-5493728106787075631L, rol(2788577329702376155L, 37));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rol_ulong()
         {
             TestUtils.AreEqual(4769317691753349395UL, rol(6894885722123239465UL, 37));
@@ -457,7 +457,7 @@ public static void rol_ulong()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ror_int()
         {
             TestUtils.AreEqual(87245360, ror(-1710129111, 11));
@@ -466,27 +466,27 @@ public static void ror_int()
             TestUtils.AreEqual(-232831845, ror(-98246768, 11));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ror_int2()
         {
             TestUtils.AreEqual(int2(87245360, -259445220), ror(int2(-1710129111, 1232136068), 11));
             TestUtils.AreEqual(int2(-1697813787, -232831845), ror(int2(1800875222, -98246768), 11));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ror_int3()
         {
             TestUtils.AreEqual(int3(87245360, -259445220, -1697813787), ror(int3(-1710129111, 1232136068, 1800875222), 11));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ror_int4()
         {
             TestUtils.AreEqual(int4(87245360, -259445220, -1697813787, -232831845), ror(int4(-1710129111, 1232136068, 1800875222, -98246768), 11));
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ror_uint()
         {
             TestUtils.AreEqual(87245360u, ror(2584838185u, 11));
@@ -495,26 +495,26 @@ public static void ror_uint()
             TestUtils.AreEqual(4062135451u, ror(4196720528u, 11));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ror_uint2()
         {
             TestUtils.AreEqual(uint2(87245360u, 4035522076u), ror(uint2(2584838185u, 1232136068u), 11));
             TestUtils.AreEqual(uint2(2597153509u, 4062135451u), ror(uint2(1800875222u, 4196720528u), 11));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ror_uint3()
         {
             TestUtils.AreEqual(uint3(87245360u, 4035522076u, 2597153509u), ror(uint3(2584838185u, 1232136068u, 1800875222u), 11));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ror_uint4()
         {
             TestUtils.AreEqual(uint4(87245360u, 4035522076u, 2597153509u, 4062135451u), ror(uint4(2584838185u, 1232136068u, 1800875222u, 4196720528u), 11));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ror_long()
         {
             TestUtils.AreEqual(4958617126915898480L, ror(6894885722123239465L, 37));
@@ -523,7 +523,7 @@ public static void ror_long()
             TestUtils.AreEqual(8389344736564320290L, ror(2788577329702376155L, 37));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ror_ulong()
         {
             TestUtils.AreEqual(4958617126915898480UL, ror(6894885722123239465UL, 37));
diff --git a/src/Tests/Tests/Shared/TestBool2.gen.cs b/src/Tests/Tests/Shared/TestBool2.gen.cs
index 3546ddd3..fe9ee45c 100644
--- a/src/Tests/Tests/Shared/TestBool2.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_constructor()
         {
             bool2 a = new bool2(false, true);
@@ -23,7 +23,7 @@ public static void bool2_constructor()
             TestUtils.AreEqual(true, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_scalar_constructor()
         {
             bool2 a = new bool2(true);
@@ -31,7 +31,7 @@ public static void bool2_scalar_constructor()
             TestUtils.AreEqual(true, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_static_constructor()
         {
             bool2 a = bool2(false, true);
@@ -39,7 +39,7 @@ public static void bool2_static_constructor()
             TestUtils.AreEqual(true, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_static_scalar_constructor()
         {
             bool2 a = bool2(true);
@@ -47,7 +47,7 @@ public static void bool2_static_scalar_constructor()
             TestUtils.AreEqual(true, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_operator_equal_wide_wide()
         {
             bool2 a0 = bool2(true, false);
@@ -71,7 +71,7 @@ public static void bool2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_operator_equal_wide_scalar()
         {
             bool2 a0 = bool2(false, true);
@@ -95,7 +95,7 @@ public static void bool2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -119,7 +119,7 @@ public static void bool2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_operator_not_equal_wide_wide()
         {
             bool2 a0 = bool2(true, true);
@@ -143,7 +143,7 @@ public static void bool2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_operator_not_equal_wide_scalar()
         {
             bool2 a0 = bool2(false, true);
@@ -167,7 +167,7 @@ public static void bool2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -191,7 +191,7 @@ public static void bool2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_operator_bitwise_and_wide_wide()
         {
             bool2 a0 = bool2(false, false);
@@ -215,7 +215,7 @@ public static void bool2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_operator_bitwise_and_wide_scalar()
         {
             bool2 a0 = bool2(true, false);
@@ -239,7 +239,7 @@ public static void bool2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -263,7 +263,7 @@ public static void bool2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_operator_bitwise_or_wide_wide()
         {
             bool2 a0 = bool2(true, true);
@@ -287,7 +287,7 @@ public static void bool2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_operator_bitwise_or_wide_scalar()
         {
             bool2 a0 = bool2(true, true);
@@ -311,7 +311,7 @@ public static void bool2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -335,7 +335,7 @@ public static void bool2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_operator_bitwise_xor_wide_wide()
         {
             bool2 a0 = bool2(true, false);
@@ -359,7 +359,7 @@ public static void bool2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_operator_bitwise_xor_wide_scalar()
         {
             bool2 a0 = bool2(false, false);
@@ -383,7 +383,7 @@ public static void bool2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -407,7 +407,7 @@ public static void bool2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_operator_logical_not()
         {
             bool2 a0 = bool2(true, true);
@@ -427,7 +427,7 @@ public static void bool2_operator_logical_not()
             TestUtils.AreEqual(r3, !a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void bool2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new bool2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestBool2x2.gen.cs b/src/Tests/Tests/Shared/TestBool2x2.gen.cs
index dbfd2fa1..af2bb68c 100644
--- a/src/Tests/Tests/Shared/TestBool2x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool2x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool2x2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x2_operator_equal_wide_wide()
         {
             bool2x2 a0 = bool2x2(true, false, true, false);
@@ -39,7 +39,7 @@ public static void bool2x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x2_operator_equal_wide_scalar()
         {
             bool2x2 a0 = bool2x2(false, true, false, false);
@@ -63,7 +63,7 @@ public static void bool2x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x2_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool2x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x2_operator_not_equal_wide_wide()
         {
             bool2x2 a0 = bool2x2(true, true, true, false);
@@ -111,7 +111,7 @@ public static void bool2x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x2_operator_not_equal_wide_scalar()
         {
             bool2x2 a0 = bool2x2(false, true, false, true);
@@ -135,7 +135,7 @@ public static void bool2x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x2_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool2x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x2_operator_bitwise_and_wide_wide()
         {
             bool2x2 a0 = bool2x2(false, false, true, true);
@@ -183,7 +183,7 @@ public static void bool2x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x2_operator_bitwise_and_wide_scalar()
         {
             bool2x2 a0 = bool2x2(true, false, false, true);
@@ -207,7 +207,7 @@ public static void bool2x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x2_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool2x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x2_operator_bitwise_or_wide_wide()
         {
             bool2x2 a0 = bool2x2(true, true, true, false);
@@ -255,7 +255,7 @@ public static void bool2x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x2_operator_bitwise_or_wide_scalar()
         {
             bool2x2 a0 = bool2x2(true, true, false, true);
@@ -279,7 +279,7 @@ public static void bool2x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x2_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool2x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x2_operator_bitwise_xor_wide_wide()
         {
             bool2x2 a0 = bool2x2(true, false, false, true);
@@ -327,7 +327,7 @@ public static void bool2x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x2_operator_bitwise_xor_wide_scalar()
         {
             bool2x2 a0 = bool2x2(false, false, true, true);
@@ -351,7 +351,7 @@ public static void bool2x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x2_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool2x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x2_operator_logical_not()
         {
             bool2x2 a0 = bool2x2(true, true, false, false);
@@ -395,7 +395,7 @@ public static void bool2x2_operator_logical_not()
             TestUtils.AreEqual(r3, !a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void bool2x2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new bool2x2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestBool2x3.gen.cs b/src/Tests/Tests/Shared/TestBool2x3.gen.cs
index e0f8f2d3..bf0f34d2 100644
--- a/src/Tests/Tests/Shared/TestBool2x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool2x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool2x3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x3_operator_equal_wide_wide()
         {
             bool2x3 a0 = bool2x3(true, false, true, false, false, true);
@@ -39,7 +39,7 @@ public static void bool2x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x3_operator_equal_wide_scalar()
         {
             bool2x3 a0 = bool2x3(false, true, false, false, false, false);
@@ -63,7 +63,7 @@ public static void bool2x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x3_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool2x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x3_operator_not_equal_wide_wide()
         {
             bool2x3 a0 = bool2x3(true, true, true, false, false, true);
@@ -111,7 +111,7 @@ public static void bool2x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x3_operator_not_equal_wide_scalar()
         {
             bool2x3 a0 = bool2x3(false, true, false, true, true, false);
@@ -135,7 +135,7 @@ public static void bool2x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x3_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool2x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x3_operator_bitwise_and_wide_wide()
         {
             bool2x3 a0 = bool2x3(false, false, true, true, false, false);
@@ -183,7 +183,7 @@ public static void bool2x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x3_operator_bitwise_and_wide_scalar()
         {
             bool2x3 a0 = bool2x3(true, false, false, true, true, false);
@@ -207,7 +207,7 @@ public static void bool2x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x3_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool2x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x3_operator_bitwise_or_wide_wide()
         {
             bool2x3 a0 = bool2x3(true, true, true, false, true, false);
@@ -255,7 +255,7 @@ public static void bool2x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x3_operator_bitwise_or_wide_scalar()
         {
             bool2x3 a0 = bool2x3(true, true, false, true, true, true);
@@ -279,7 +279,7 @@ public static void bool2x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x3_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool2x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x3_operator_bitwise_xor_wide_wide()
         {
             bool2x3 a0 = bool2x3(true, false, false, true, false, false);
@@ -327,7 +327,7 @@ public static void bool2x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x3_operator_bitwise_xor_wide_scalar()
         {
             bool2x3 a0 = bool2x3(false, false, true, true, false, false);
@@ -351,7 +351,7 @@ public static void bool2x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x3_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool2x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x3_operator_logical_not()
         {
             bool2x3 a0 = bool2x3(true, true, false, false, true, false);
@@ -395,7 +395,7 @@ public static void bool2x3_operator_logical_not()
             TestUtils.AreEqual(r3, !a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void bool2x3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new bool2x3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestBool2x4.gen.cs b/src/Tests/Tests/Shared/TestBool2x4.gen.cs
index 4200e9ee..3310b755 100644
--- a/src/Tests/Tests/Shared/TestBool2x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool2x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool2x4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x4_operator_equal_wide_wide()
         {
             bool2x4 a0 = bool2x4(true, false, true, false, false, true, false, false);
@@ -39,7 +39,7 @@ public static void bool2x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x4_operator_equal_wide_scalar()
         {
             bool2x4 a0 = bool2x4(false, true, false, false, false, false, true, false);
@@ -63,7 +63,7 @@ public static void bool2x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x4_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool2x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x4_operator_not_equal_wide_wide()
         {
             bool2x4 a0 = bool2x4(true, true, true, false, false, true, false, false);
@@ -111,7 +111,7 @@ public static void bool2x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x4_operator_not_equal_wide_scalar()
         {
             bool2x4 a0 = bool2x4(false, true, false, true, true, false, false, false);
@@ -135,7 +135,7 @@ public static void bool2x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x4_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool2x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x4_operator_bitwise_and_wide_wide()
         {
             bool2x4 a0 = bool2x4(false, false, true, true, false, false, true, true);
@@ -183,7 +183,7 @@ public static void bool2x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x4_operator_bitwise_and_wide_scalar()
         {
             bool2x4 a0 = bool2x4(true, false, false, true, true, false, false, false);
@@ -207,7 +207,7 @@ public static void bool2x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x4_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool2x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x4_operator_bitwise_or_wide_wide()
         {
             bool2x4 a0 = bool2x4(true, true, true, false, true, false, true, true);
@@ -255,7 +255,7 @@ public static void bool2x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x4_operator_bitwise_or_wide_scalar()
         {
             bool2x4 a0 = bool2x4(true, true, false, true, true, true, true, false);
@@ -279,7 +279,7 @@ public static void bool2x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x4_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool2x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x4_operator_bitwise_xor_wide_wide()
         {
             bool2x4 a0 = bool2x4(true, false, false, true, false, false, false, true);
@@ -327,7 +327,7 @@ public static void bool2x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x4_operator_bitwise_xor_wide_scalar()
         {
             bool2x4 a0 = bool2x4(false, false, true, true, false, false, false, false);
@@ -351,7 +351,7 @@ public static void bool2x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x4_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool2x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2x4_operator_logical_not()
         {
             bool2x4 a0 = bool2x4(true, true, false, false, true, false, true, false);
@@ -395,7 +395,7 @@ public static void bool2x4_operator_logical_not()
             TestUtils.AreEqual(r3, !a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void bool2x4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new bool2x4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestBool3.gen.cs b/src/Tests/Tests/Shared/TestBool3.gen.cs
index e6b69c43..d66353aa 100644
--- a/src/Tests/Tests/Shared/TestBool3.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_constructor()
         {
             bool3 a = new bool3(false, true, false);
@@ -24,7 +24,7 @@ public static void bool3_constructor()
             TestUtils.AreEqual(false, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_scalar_constructor()
         {
             bool3 a = new bool3(true);
@@ -33,7 +33,7 @@ public static void bool3_scalar_constructor()
             TestUtils.AreEqual(true, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_static_constructor()
         {
             bool3 a = bool3(false, true, false);
@@ -42,7 +42,7 @@ public static void bool3_static_constructor()
             TestUtils.AreEqual(false, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_static_scalar_constructor()
         {
             bool3 a = bool3(true);
@@ -51,7 +51,7 @@ public static void bool3_static_scalar_constructor()
             TestUtils.AreEqual(true, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_operator_equal_wide_wide()
         {
             bool3 a0 = bool3(true, false, true);
@@ -75,7 +75,7 @@ public static void bool3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_operator_equal_wide_scalar()
         {
             bool3 a0 = bool3(false, true, false);
@@ -99,7 +99,7 @@ public static void bool3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -123,7 +123,7 @@ public static void bool3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_operator_not_equal_wide_wide()
         {
             bool3 a0 = bool3(true, true, true);
@@ -147,7 +147,7 @@ public static void bool3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_operator_not_equal_wide_scalar()
         {
             bool3 a0 = bool3(false, true, false);
@@ -171,7 +171,7 @@ public static void bool3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -195,7 +195,7 @@ public static void bool3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_operator_bitwise_and_wide_wide()
         {
             bool3 a0 = bool3(false, false, true);
@@ -219,7 +219,7 @@ public static void bool3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_operator_bitwise_and_wide_scalar()
         {
             bool3 a0 = bool3(true, false, false);
@@ -243,7 +243,7 @@ public static void bool3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -267,7 +267,7 @@ public static void bool3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_operator_bitwise_or_wide_wide()
         {
             bool3 a0 = bool3(true, true, true);
@@ -291,7 +291,7 @@ public static void bool3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_operator_bitwise_or_wide_scalar()
         {
             bool3 a0 = bool3(true, true, false);
@@ -315,7 +315,7 @@ public static void bool3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -339,7 +339,7 @@ public static void bool3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_operator_bitwise_xor_wide_wide()
         {
             bool3 a0 = bool3(true, false, false);
@@ -363,7 +363,7 @@ public static void bool3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_operator_bitwise_xor_wide_scalar()
         {
             bool3 a0 = bool3(false, false, true);
@@ -387,7 +387,7 @@ public static void bool3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -411,7 +411,7 @@ public static void bool3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_operator_logical_not()
         {
             bool3 a0 = bool3(true, true, false);
@@ -431,7 +431,7 @@ public static void bool3_operator_logical_not()
             TestUtils.AreEqual(r3, !a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void bool3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new bool3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestBool3x2.gen.cs b/src/Tests/Tests/Shared/TestBool3x2.gen.cs
index d41f918c..5be3fb7b 100644
--- a/src/Tests/Tests/Shared/TestBool3x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool3x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool3x2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x2_operator_equal_wide_wide()
         {
             bool3x2 a0 = bool3x2(true, false, true, false, false, true);
@@ -39,7 +39,7 @@ public static void bool3x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x2_operator_equal_wide_scalar()
         {
             bool3x2 a0 = bool3x2(false, true, false, false, false, false);
@@ -63,7 +63,7 @@ public static void bool3x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x2_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool3x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x2_operator_not_equal_wide_wide()
         {
             bool3x2 a0 = bool3x2(true, true, true, false, false, true);
@@ -111,7 +111,7 @@ public static void bool3x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x2_operator_not_equal_wide_scalar()
         {
             bool3x2 a0 = bool3x2(false, true, false, true, true, false);
@@ -135,7 +135,7 @@ public static void bool3x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x2_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool3x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x2_operator_bitwise_and_wide_wide()
         {
             bool3x2 a0 = bool3x2(false, false, true, true, false, false);
@@ -183,7 +183,7 @@ public static void bool3x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x2_operator_bitwise_and_wide_scalar()
         {
             bool3x2 a0 = bool3x2(true, false, false, true, true, false);
@@ -207,7 +207,7 @@ public static void bool3x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x2_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool3x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x2_operator_bitwise_or_wide_wide()
         {
             bool3x2 a0 = bool3x2(true, true, true, false, true, false);
@@ -255,7 +255,7 @@ public static void bool3x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x2_operator_bitwise_or_wide_scalar()
         {
             bool3x2 a0 = bool3x2(true, true, false, true, true, true);
@@ -279,7 +279,7 @@ public static void bool3x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x2_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool3x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x2_operator_bitwise_xor_wide_wide()
         {
             bool3x2 a0 = bool3x2(true, false, false, true, false, false);
@@ -327,7 +327,7 @@ public static void bool3x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x2_operator_bitwise_xor_wide_scalar()
         {
             bool3x2 a0 = bool3x2(false, false, true, true, false, false);
@@ -351,7 +351,7 @@ public static void bool3x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x2_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool3x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x2_operator_logical_not()
         {
             bool3x2 a0 = bool3x2(true, true, false, false, true, false);
@@ -395,7 +395,7 @@ public static void bool3x2_operator_logical_not()
             TestUtils.AreEqual(r3, !a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void bool3x2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new bool3x2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestBool3x3.gen.cs b/src/Tests/Tests/Shared/TestBool3x3.gen.cs
index 4a2301d9..4541a352 100644
--- a/src/Tests/Tests/Shared/TestBool3x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool3x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool3x3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x3_operator_equal_wide_wide()
         {
             bool3x3 a0 = bool3x3(true, false, true, false, false, true, false, false, true);
@@ -39,7 +39,7 @@ public static void bool3x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x3_operator_equal_wide_scalar()
         {
             bool3x3 a0 = bool3x3(false, true, false, false, false, false, true, false, false);
@@ -63,7 +63,7 @@ public static void bool3x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x3_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool3x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x3_operator_not_equal_wide_wide()
         {
             bool3x3 a0 = bool3x3(true, true, true, false, false, true, false, false, false);
@@ -111,7 +111,7 @@ public static void bool3x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x3_operator_not_equal_wide_scalar()
         {
             bool3x3 a0 = bool3x3(false, true, false, true, true, false, false, false, false);
@@ -135,7 +135,7 @@ public static void bool3x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x3_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool3x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x3_operator_bitwise_and_wide_wide()
         {
             bool3x3 a0 = bool3x3(false, false, true, true, false, false, true, true, true);
@@ -183,7 +183,7 @@ public static void bool3x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x3_operator_bitwise_and_wide_scalar()
         {
             bool3x3 a0 = bool3x3(true, false, false, true, true, false, false, false, false);
@@ -207,7 +207,7 @@ public static void bool3x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x3_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool3x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x3_operator_bitwise_or_wide_wide()
         {
             bool3x3 a0 = bool3x3(true, true, true, false, true, false, true, true, false);
@@ -255,7 +255,7 @@ public static void bool3x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x3_operator_bitwise_or_wide_scalar()
         {
             bool3x3 a0 = bool3x3(true, true, false, true, true, true, true, false, true);
@@ -279,7 +279,7 @@ public static void bool3x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x3_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool3x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x3_operator_bitwise_xor_wide_wide()
         {
             bool3x3 a0 = bool3x3(true, false, false, true, false, false, false, true, false);
@@ -327,7 +327,7 @@ public static void bool3x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x3_operator_bitwise_xor_wide_scalar()
         {
             bool3x3 a0 = bool3x3(false, false, true, true, false, false, false, false, false);
@@ -351,7 +351,7 @@ public static void bool3x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x3_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool3x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x3_operator_logical_not()
         {
             bool3x3 a0 = bool3x3(true, true, false, false, true, false, true, false, true);
@@ -395,7 +395,7 @@ public static void bool3x3_operator_logical_not()
             TestUtils.AreEqual(r3, !a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void bool3x3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new bool3x3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestBool3x4.gen.cs b/src/Tests/Tests/Shared/TestBool3x4.gen.cs
index c0981361..02565c51 100644
--- a/src/Tests/Tests/Shared/TestBool3x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool3x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool3x4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x4_operator_equal_wide_wide()
         {
             bool3x4 a0 = bool3x4(true, false, true, false, false, true, false, false, true, false, true, false);
@@ -39,7 +39,7 @@ public static void bool3x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x4_operator_equal_wide_scalar()
         {
             bool3x4 a0 = bool3x4(false, true, false, false, false, false, true, false, false, false, true, true);
@@ -63,7 +63,7 @@ public static void bool3x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x4_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool3x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x4_operator_not_equal_wide_wide()
         {
             bool3x4 a0 = bool3x4(true, true, true, false, false, true, false, false, false, false, true, true);
@@ -111,7 +111,7 @@ public static void bool3x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x4_operator_not_equal_wide_scalar()
         {
             bool3x4 a0 = bool3x4(false, true, false, true, true, false, false, false, false, false, false, false);
@@ -135,7 +135,7 @@ public static void bool3x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x4_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool3x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x4_operator_bitwise_and_wide_wide()
         {
             bool3x4 a0 = bool3x4(false, false, true, true, false, false, true, true, true, false, true, true);
@@ -183,7 +183,7 @@ public static void bool3x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x4_operator_bitwise_and_wide_scalar()
         {
             bool3x4 a0 = bool3x4(true, false, false, true, true, false, false, false, false, false, true, true);
@@ -207,7 +207,7 @@ public static void bool3x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x4_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool3x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x4_operator_bitwise_or_wide_wide()
         {
             bool3x4 a0 = bool3x4(true, true, true, false, true, false, true, true, false, true, true, true);
@@ -255,7 +255,7 @@ public static void bool3x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x4_operator_bitwise_or_wide_scalar()
         {
             bool3x4 a0 = bool3x4(true, true, false, true, true, true, true, false, true, false, false, true);
@@ -279,7 +279,7 @@ public static void bool3x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x4_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool3x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x4_operator_bitwise_xor_wide_wide()
         {
             bool3x4 a0 = bool3x4(true, false, false, true, false, false, false, true, false, false, true, true);
@@ -327,7 +327,7 @@ public static void bool3x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x4_operator_bitwise_xor_wide_scalar()
         {
             bool3x4 a0 = bool3x4(false, false, true, true, false, false, false, false, false, false, false, true);
@@ -351,7 +351,7 @@ public static void bool3x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x4_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool3x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3x4_operator_logical_not()
         {
             bool3x4 a0 = bool3x4(true, true, false, false, true, false, true, false, true, false, false, false);
@@ -395,7 +395,7 @@ public static void bool3x4_operator_logical_not()
             TestUtils.AreEqual(r3, !a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void bool3x4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new bool3x4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestBool4.gen.cs b/src/Tests/Tests/Shared/TestBool4.gen.cs
index 69e823ab..4faf4e36 100644
--- a/src/Tests/Tests/Shared/TestBool4.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_constructor()
         {
             bool4 a = new bool4(false, true, false, true);
@@ -25,7 +25,7 @@ public static void bool4_constructor()
             TestUtils.AreEqual(true, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_scalar_constructor()
         {
             bool4 a = new bool4(true);
@@ -35,7 +35,7 @@ public static void bool4_scalar_constructor()
             TestUtils.AreEqual(true, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_static_constructor()
         {
             bool4 a = bool4(false, true, false, true);
@@ -45,7 +45,7 @@ public static void bool4_static_constructor()
             TestUtils.AreEqual(true, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_static_scalar_constructor()
         {
             bool4 a = bool4(true);
@@ -55,7 +55,7 @@ public static void bool4_static_scalar_constructor()
             TestUtils.AreEqual(true, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_operator_equal_wide_wide()
         {
             bool4 a0 = bool4(true, false, true, false);
@@ -79,7 +79,7 @@ public static void bool4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_operator_equal_wide_scalar()
         {
             bool4 a0 = bool4(false, true, false, false);
@@ -103,7 +103,7 @@ public static void bool4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -127,7 +127,7 @@ public static void bool4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_operator_not_equal_wide_wide()
         {
             bool4 a0 = bool4(true, true, true, false);
@@ -151,7 +151,7 @@ public static void bool4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_operator_not_equal_wide_scalar()
         {
             bool4 a0 = bool4(false, true, false, true);
@@ -175,7 +175,7 @@ public static void bool4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -199,7 +199,7 @@ public static void bool4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_operator_bitwise_and_wide_wide()
         {
             bool4 a0 = bool4(false, false, true, true);
@@ -223,7 +223,7 @@ public static void bool4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_operator_bitwise_and_wide_scalar()
         {
             bool4 a0 = bool4(true, false, false, true);
@@ -247,7 +247,7 @@ public static void bool4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -271,7 +271,7 @@ public static void bool4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_operator_bitwise_or_wide_wide()
         {
             bool4 a0 = bool4(true, true, true, false);
@@ -295,7 +295,7 @@ public static void bool4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_operator_bitwise_or_wide_scalar()
         {
             bool4 a0 = bool4(true, true, false, true);
@@ -319,7 +319,7 @@ public static void bool4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -343,7 +343,7 @@ public static void bool4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_operator_bitwise_xor_wide_wide()
         {
             bool4 a0 = bool4(true, false, false, true);
@@ -367,7 +367,7 @@ public static void bool4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_operator_bitwise_xor_wide_scalar()
         {
             bool4 a0 = bool4(false, false, true, true);
@@ -391,7 +391,7 @@ public static void bool4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -415,7 +415,7 @@ public static void bool4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_operator_logical_not()
         {
             bool4 a0 = bool4(true, true, false, false);
@@ -435,7 +435,7 @@ public static void bool4_operator_logical_not()
             TestUtils.AreEqual(r3, !a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void bool4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new bool4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestBool4x2.gen.cs b/src/Tests/Tests/Shared/TestBool4x2.gen.cs
index 0a2a54ca..b7585d45 100644
--- a/src/Tests/Tests/Shared/TestBool4x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool4x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool4x2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x2_operator_equal_wide_wide()
         {
             bool4x2 a0 = bool4x2(true, false, true, false, false, true, false, false);
@@ -39,7 +39,7 @@ public static void bool4x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x2_operator_equal_wide_scalar()
         {
             bool4x2 a0 = bool4x2(false, true, false, false, false, false, true, false);
@@ -63,7 +63,7 @@ public static void bool4x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x2_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool4x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x2_operator_not_equal_wide_wide()
         {
             bool4x2 a0 = bool4x2(true, true, true, false, false, true, false, false);
@@ -111,7 +111,7 @@ public static void bool4x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x2_operator_not_equal_wide_scalar()
         {
             bool4x2 a0 = bool4x2(false, true, false, true, true, false, false, false);
@@ -135,7 +135,7 @@ public static void bool4x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x2_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool4x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x2_operator_bitwise_and_wide_wide()
         {
             bool4x2 a0 = bool4x2(false, false, true, true, false, false, true, true);
@@ -183,7 +183,7 @@ public static void bool4x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x2_operator_bitwise_and_wide_scalar()
         {
             bool4x2 a0 = bool4x2(true, false, false, true, true, false, false, false);
@@ -207,7 +207,7 @@ public static void bool4x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x2_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool4x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x2_operator_bitwise_or_wide_wide()
         {
             bool4x2 a0 = bool4x2(true, true, true, false, true, false, true, true);
@@ -255,7 +255,7 @@ public static void bool4x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x2_operator_bitwise_or_wide_scalar()
         {
             bool4x2 a0 = bool4x2(true, true, false, true, true, true, true, false);
@@ -279,7 +279,7 @@ public static void bool4x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x2_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool4x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x2_operator_bitwise_xor_wide_wide()
         {
             bool4x2 a0 = bool4x2(true, false, false, true, false, false, false, true);
@@ -327,7 +327,7 @@ public static void bool4x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x2_operator_bitwise_xor_wide_scalar()
         {
             bool4x2 a0 = bool4x2(false, false, true, true, false, false, false, false);
@@ -351,7 +351,7 @@ public static void bool4x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x2_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool4x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x2_operator_logical_not()
         {
             bool4x2 a0 = bool4x2(true, true, false, false, true, false, true, false);
@@ -395,7 +395,7 @@ public static void bool4x2_operator_logical_not()
             TestUtils.AreEqual(r3, !a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void bool4x2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new bool4x2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestBool4x3.gen.cs b/src/Tests/Tests/Shared/TestBool4x3.gen.cs
index 8be23641..012ad7e5 100644
--- a/src/Tests/Tests/Shared/TestBool4x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool4x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool4x3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x3_operator_equal_wide_wide()
         {
             bool4x3 a0 = bool4x3(true, false, true, false, false, true, false, false, true, false, true, false);
@@ -39,7 +39,7 @@ public static void bool4x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x3_operator_equal_wide_scalar()
         {
             bool4x3 a0 = bool4x3(false, true, false, false, false, false, true, false, false, false, true, true);
@@ -63,7 +63,7 @@ public static void bool4x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x3_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool4x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x3_operator_not_equal_wide_wide()
         {
             bool4x3 a0 = bool4x3(true, true, true, false, false, true, false, false, false, false, true, true);
@@ -111,7 +111,7 @@ public static void bool4x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x3_operator_not_equal_wide_scalar()
         {
             bool4x3 a0 = bool4x3(false, true, false, true, true, false, false, false, false, false, false, false);
@@ -135,7 +135,7 @@ public static void bool4x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x3_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool4x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x3_operator_bitwise_and_wide_wide()
         {
             bool4x3 a0 = bool4x3(false, false, true, true, false, false, true, true, true, false, true, true);
@@ -183,7 +183,7 @@ public static void bool4x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x3_operator_bitwise_and_wide_scalar()
         {
             bool4x3 a0 = bool4x3(true, false, false, true, true, false, false, false, false, false, true, true);
@@ -207,7 +207,7 @@ public static void bool4x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x3_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool4x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x3_operator_bitwise_or_wide_wide()
         {
             bool4x3 a0 = bool4x3(true, true, true, false, true, false, true, true, false, true, true, true);
@@ -255,7 +255,7 @@ public static void bool4x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x3_operator_bitwise_or_wide_scalar()
         {
             bool4x3 a0 = bool4x3(true, true, false, true, true, true, true, false, true, false, false, true);
@@ -279,7 +279,7 @@ public static void bool4x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x3_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool4x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x3_operator_bitwise_xor_wide_wide()
         {
             bool4x3 a0 = bool4x3(true, false, false, true, false, false, false, true, false, false, true, true);
@@ -327,7 +327,7 @@ public static void bool4x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x3_operator_bitwise_xor_wide_scalar()
         {
             bool4x3 a0 = bool4x3(false, false, true, true, false, false, false, false, false, false, false, true);
@@ -351,7 +351,7 @@ public static void bool4x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x3_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool4x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x3_operator_logical_not()
         {
             bool4x3 a0 = bool4x3(true, true, false, false, true, false, true, false, true, false, false, false);
@@ -395,7 +395,7 @@ public static void bool4x3_operator_logical_not()
             TestUtils.AreEqual(r3, !a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void bool4x3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new bool4x3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestBool4x4.gen.cs b/src/Tests/Tests/Shared/TestBool4x4.gen.cs
index c83c5d8d..9cb7e412 100644
--- a/src/Tests/Tests/Shared/TestBool4x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool4x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool4x4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x4_operator_equal_wide_wide()
         {
             bool4x4 a0 = bool4x4(true, false, true, false, false, true, false, false, true, false, true, false, true, true, false, true);
@@ -39,7 +39,7 @@ public static void bool4x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x4_operator_equal_wide_scalar()
         {
             bool4x4 a0 = bool4x4(false, true, false, false, false, false, true, false, false, false, true, true, false, true, false, true);
@@ -63,7 +63,7 @@ public static void bool4x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x4_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool4x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x4_operator_not_equal_wide_wide()
         {
             bool4x4 a0 = bool4x4(true, true, true, false, false, true, false, false, false, false, true, true, true, true, true, true);
@@ -111,7 +111,7 @@ public static void bool4x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x4_operator_not_equal_wide_scalar()
         {
             bool4x4 a0 = bool4x4(false, true, false, true, true, false, false, false, false, false, false, false, false, true, false, false);
@@ -135,7 +135,7 @@ public static void bool4x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x4_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool4x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x4_operator_bitwise_and_wide_wide()
         {
             bool4x4 a0 = bool4x4(false, false, true, true, false, false, true, true, true, false, true, true, true, true, false, false);
@@ -183,7 +183,7 @@ public static void bool4x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x4_operator_bitwise_and_wide_scalar()
         {
             bool4x4 a0 = bool4x4(true, false, false, true, true, false, false, false, false, false, true, true, true, false, false, true);
@@ -207,7 +207,7 @@ public static void bool4x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x4_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool4x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x4_operator_bitwise_or_wide_wide()
         {
             bool4x4 a0 = bool4x4(true, true, true, false, true, false, true, true, false, true, true, true, true, true, true, false);
@@ -255,7 +255,7 @@ public static void bool4x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x4_operator_bitwise_or_wide_scalar()
         {
             bool4x4 a0 = bool4x4(true, true, false, true, true, true, true, false, true, false, false, true, false, false, true, false);
@@ -279,7 +279,7 @@ public static void bool4x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x4_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool4x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x4_operator_bitwise_xor_wide_wide()
         {
             bool4x4 a0 = bool4x4(true, false, false, true, false, false, false, true, false, false, true, true, false, false, true, false);
@@ -327,7 +327,7 @@ public static void bool4x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x4_operator_bitwise_xor_wide_scalar()
         {
             bool4x4 a0 = bool4x4(false, false, true, true, false, false, false, false, false, false, false, true, false, true, true, true);
@@ -351,7 +351,7 @@ public static void bool4x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x4_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool4x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4x4_operator_logical_not()
         {
             bool4x4 a0 = bool4x4(true, true, false, false, true, false, true, false, true, false, false, false, false, true, true, false);
@@ -395,7 +395,7 @@ public static void bool4x4_operator_logical_not()
             TestUtils.AreEqual(r3, !a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void bool4x4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new bool4x4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestDouble2.gen.cs b/src/Tests/Tests/Shared/TestDouble2.gen.cs
index cd44e120..30a3f849 100644
--- a/src/Tests/Tests/Shared/TestDouble2.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble2.gen.cs
@@ -15,14 +15,14 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_zero()
         {
             TestUtils.AreEqual(0.0, double2.zero.x);
             TestUtils.AreEqual(0.0, double2.zero.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_constructor()
         {
             double2 a = new double2(1, 2);
@@ -30,7 +30,7 @@ public static void double2_constructor()
             TestUtils.AreEqual(2, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_scalar_constructor()
         {
             double2 a = new double2(17.0);
@@ -38,7 +38,7 @@ public static void double2_scalar_constructor()
             TestUtils.AreEqual(17.0, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_static_constructor()
         {
             double2 a = double2(1, 2);
@@ -46,7 +46,7 @@ public static void double2_static_constructor()
             TestUtils.AreEqual(2, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_static_scalar_constructor()
         {
             double2 a = double2(17.0);
@@ -54,7 +54,7 @@ public static void double2_static_scalar_constructor()
             TestUtils.AreEqual(17.0, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_equal_wide_wide()
         {
             double2 a0 = double2(492.15758275061728, -495.20632027797694);
@@ -78,7 +78,7 @@ public static void double2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_equal_wide_scalar()
         {
             double2 a0 = double2(-303.2300766926399, 451.52631327674089);
@@ -102,7 +102,7 @@ public static void double2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -126,7 +126,7 @@ public static void double2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_not_equal_wide_wide()
         {
             double2 a0 = double2(430.8425316432689, 104.69001798736394);
@@ -150,7 +150,7 @@ public static void double2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_not_equal_wide_scalar()
         {
             double2 a0 = double2(-16.914588697680529, 168.83411486858233);
@@ -174,7 +174,7 @@ public static void double2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -198,7 +198,7 @@ public static void double2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_less_wide_wide()
         {
             double2 a0 = double2(196.84256825076534, 336.40979997087732);
@@ -222,7 +222,7 @@ public static void double2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_less_wide_scalar()
         {
             double2 a0 = double2(-132.05731708000292, -192.46500477216438);
@@ -246,7 +246,7 @@ public static void double2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -270,7 +270,7 @@ public static void double2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_greater_wide_wide()
         {
             double2 a0 = double2(483.50140141113729, 310.81563415695712);
@@ -294,7 +294,7 @@ public static void double2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_greater_wide_scalar()
         {
             double2 a0 = double2(64.317918092160426, -397.70346445483318);
@@ -318,7 +318,7 @@ public static void double2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -342,7 +342,7 @@ public static void double2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_less_equal_wide_wide()
         {
             double2 a0 = double2(-438.52313753521219, 210.48942837980087);
@@ -366,7 +366,7 @@ public static void double2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_less_equal_wide_scalar()
         {
             double2 a0 = double2(193.4958237118534, 168.91555197952107);
@@ -390,7 +390,7 @@ public static void double2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -414,7 +414,7 @@ public static void double2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_greater_equal_wide_wide()
         {
             double2 a0 = double2(-507.92858409692, 504.49748181947393);
@@ -438,7 +438,7 @@ public static void double2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_greater_equal_wide_scalar()
         {
             double2 a0 = double2(465.15218732559686, -424.8860745024337);
@@ -462,7 +462,7 @@ public static void double2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -486,7 +486,7 @@ public static void double2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_add_wide_wide()
         {
             double2 a0 = double2(506.12905263627374, -501.77980803967444);
@@ -510,7 +510,7 @@ public static void double2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_add_wide_scalar()
         {
             double2 a0 = double2(-194.51420387742769, 338.54838696985894);
@@ -534,7 +534,7 @@ public static void double2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -558,7 +558,7 @@ public static void double2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_sub_wide_wide()
         {
             double2 a0 = double2(160.4922617229131, 11.223957305412682);
@@ -582,7 +582,7 @@ public static void double2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_sub_wide_scalar()
         {
             double2 a0 = double2(207.38960108877609, 248.45773684627272);
@@ -606,7 +606,7 @@ public static void double2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -630,7 +630,7 @@ public static void double2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_mul_wide_wide()
         {
             double2 a0 = double2(-482.71381710596097, -407.29348559272171);
@@ -654,7 +654,7 @@ public static void double2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_mul_wide_scalar()
         {
             double2 a0 = double2(-96.318821236639678, -277.14229239017811);
@@ -678,7 +678,7 @@ public static void double2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -702,7 +702,7 @@ public static void double2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_div_wide_wide()
         {
             double2 a0 = double2(-353.13144390337703, -102.79985456485292);
@@ -726,7 +726,7 @@ public static void double2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_div_wide_scalar()
         {
             double2 a0 = double2(171.34242184988341, 0.10338377957384637);
@@ -750,7 +750,7 @@ public static void double2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -774,7 +774,7 @@ public static void double2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_mod_wide_wide()
         {
             double2 a0 = double2(-388.81249422059045, 181.68118842955732);
@@ -798,7 +798,7 @@ public static void double2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_mod_wide_scalar()
         {
             double2 a0 = double2(-244.49962889612635, -211.81931958525411);
@@ -822,7 +822,7 @@ public static void double2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -846,7 +846,7 @@ public static void double2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_plus()
         {
             double2 a0 = double2(-418.82956357432045, -405.79894823851015);
@@ -866,7 +866,7 @@ public static void double2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_neg()
         {
             double2 a0 = double2(148.46174890755753, -467.12267873581624);
@@ -886,7 +886,7 @@ public static void double2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_prefix_inc()
         {
             double2 a0 = double2(-139.84208137348389, -56.743654039103376);
@@ -906,7 +906,7 @@ public static void double2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_postfix_inc()
         {
             double2 a0 = double2(-396.6697396695007, 511.20749378167443);
@@ -926,7 +926,7 @@ public static void double2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_prefix_dec()
         {
             double2 a0 = double2(123.12869626056806, 256.8437465433235);
@@ -946,7 +946,7 @@ public static void double2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_operator_postfix_dec()
         {
             double2 a0 = double2(379.68831723727669, 302.69287814884115);
@@ -966,7 +966,7 @@ public static void double2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_shuffle_result_1()
         {
             double2 a = double2(0, 1);
@@ -978,7 +978,7 @@ public static void double2_shuffle_result_1()
             TestUtils.AreEqual((3), shuffle(a, b, ShuffleComponent.RightY));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_shuffle_result_2()
         {
             double2 a = double2(0, 1);
@@ -1002,7 +1002,7 @@ public static void double2_shuffle_result_2()
             TestUtils.AreEqual(double2(3, 3), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_shuffle_result_3()
         {
             double2 a = double2(0, 1);
@@ -1026,7 +1026,7 @@ public static void double2_shuffle_result_3()
             TestUtils.AreEqual(double3(3, 1, 1), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_shuffle_result_4()
         {
             double2 a = double2(0, 1);
@@ -1050,7 +1050,7 @@ public static void double2_shuffle_result_4()
             TestUtils.AreEqual(double4(2, 0, 0, 0), shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX));
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void double2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new double2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestDouble2x2.gen.cs b/src/Tests/Tests/Shared/TestDouble2x2.gen.cs
index c7fc90d5..5531de5f 100644
--- a/src/Tests/Tests/Shared/TestDouble2x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble2x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble2x2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_zero()
         {
             TestUtils.AreEqual(0.0, double2x2.zero.c0.x);
@@ -24,7 +24,7 @@ public static void double2x2_zero()
             TestUtils.AreEqual(0.0, double2x2.zero.c1.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_identity()
         {
             TestUtils.AreEqual(1.0, double2x2.identity.c0.x);
@@ -33,7 +33,7 @@ public static void double2x2_identity()
             TestUtils.AreEqual(1.0, double2x2.identity.c1.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_equal_wide_wide()
         {
             double2x2 a0 = double2x2(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182);
@@ -57,7 +57,7 @@ public static void double2x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_equal_wide_scalar()
         {
             double2x2 a0 = double2x2(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995);
@@ -81,7 +81,7 @@ public static void double2x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -105,7 +105,7 @@ public static void double2x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_not_equal_wide_wide()
         {
             double2x2 a0 = double2x2(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048);
@@ -129,7 +129,7 @@ public static void double2x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_not_equal_wide_scalar()
         {
             double2x2 a0 = double2x2(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137);
@@ -153,7 +153,7 @@ public static void double2x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -177,7 +177,7 @@ public static void double2x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_less_wide_wide()
         {
             double2x2 a0 = double2x2(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963);
@@ -201,7 +201,7 @@ public static void double2x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_less_wide_scalar()
         {
             double2x2 a0 = double2x2(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561);
@@ -225,7 +225,7 @@ public static void double2x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -249,7 +249,7 @@ public static void double2x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_greater_wide_wide()
         {
             double2x2 a0 = double2x2(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671);
@@ -273,7 +273,7 @@ public static void double2x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_greater_wide_scalar()
         {
             double2x2 a0 = double2x2(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157);
@@ -297,7 +297,7 @@ public static void double2x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -321,7 +321,7 @@ public static void double2x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_less_equal_wide_wide()
         {
             double2x2 a0 = double2x2(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857);
@@ -345,7 +345,7 @@ public static void double2x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_less_equal_wide_scalar()
         {
             double2x2 a0 = double2x2(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292);
@@ -369,7 +369,7 @@ public static void double2x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -393,7 +393,7 @@ public static void double2x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_greater_equal_wide_wide()
         {
             double2x2 a0 = double2x2(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784);
@@ -417,7 +417,7 @@ public static void double2x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_greater_equal_wide_scalar()
         {
             double2x2 a0 = double2x2(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356);
@@ -441,7 +441,7 @@ public static void double2x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -465,7 +465,7 @@ public static void double2x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_add_wide_wide()
         {
             double2x2 a0 = double2x2(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274);
@@ -489,7 +489,7 @@ public static void double2x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_add_wide_scalar()
         {
             double2x2 a0 = double2x2(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752);
@@ -513,7 +513,7 @@ public static void double2x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -537,7 +537,7 @@ public static void double2x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_sub_wide_wide()
         {
             double2x2 a0 = double2x2(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311);
@@ -561,7 +561,7 @@ public static void double2x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_sub_wide_scalar()
         {
             double2x2 a0 = double2x2(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506);
@@ -585,7 +585,7 @@ public static void double2x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -609,7 +609,7 @@ public static void double2x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_mul_wide_wide()
         {
             double2x2 a0 = double2x2(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182);
@@ -633,7 +633,7 @@ public static void double2x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_mul_wide_scalar()
         {
             double2x2 a0 = double2x2(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409);
@@ -657,7 +657,7 @@ public static void double2x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -681,7 +681,7 @@ public static void double2x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_div_wide_wide()
         {
             double2x2 a0 = double2x2(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176);
@@ -705,7 +705,7 @@ public static void double2x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_div_wide_scalar()
         {
             double2x2 a0 = double2x2(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078);
@@ -729,7 +729,7 @@ public static void double2x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -753,7 +753,7 @@ public static void double2x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_mod_wide_wide()
         {
             double2x2 a0 = double2x2(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813);
@@ -777,7 +777,7 @@ public static void double2x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_mod_wide_scalar()
         {
             double2x2 a0 = double2x2(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672);
@@ -801,7 +801,7 @@ public static void double2x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -825,7 +825,7 @@ public static void double2x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_plus()
         {
             double2x2 a0 = double2x2(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421);
@@ -845,7 +845,7 @@ public static void double2x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_neg()
         {
             double2x2 a0 = double2x2(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463);
@@ -865,7 +865,7 @@ public static void double2x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_prefix_inc()
         {
             double2x2 a0 = double2x2(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962);
@@ -885,7 +885,7 @@ public static void double2x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_postfix_inc()
         {
             double2x2 a0 = double2x2(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153);
@@ -905,7 +905,7 @@ public static void double2x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_prefix_dec()
         {
             double2x2 a0 = double2x2(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563);
@@ -925,7 +925,7 @@ public static void double2x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x2_operator_postfix_dec()
         {
             double2x2 a0 = double2x2(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962);
@@ -945,7 +945,7 @@ public static void double2x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void double2x2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new double2x2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestDouble2x3.gen.cs b/src/Tests/Tests/Shared/TestDouble2x3.gen.cs
index d95bba8d..20df3853 100644
--- a/src/Tests/Tests/Shared/TestDouble2x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble2x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble2x3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_zero()
         {
             TestUtils.AreEqual(0.0, double2x3.zero.c0.x);
@@ -26,7 +26,7 @@ public static void double2x3_zero()
             TestUtils.AreEqual(0.0, double2x3.zero.c2.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_equal_wide_wide()
         {
             double2x3 a0 = double2x3(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749);
@@ -50,7 +50,7 @@ public static void double2x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_equal_wide_scalar()
         {
             double2x3 a0 = double2x3(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315);
@@ -74,7 +74,7 @@ public static void double2x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -98,7 +98,7 @@ public static void double2x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_not_equal_wide_wide()
         {
             double2x3 a0 = double2x3(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379);
@@ -122,7 +122,7 @@ public static void double2x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_not_equal_wide_scalar()
         {
             double2x3 a0 = double2x3(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959);
@@ -146,7 +146,7 @@ public static void double2x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -170,7 +170,7 @@ public static void double2x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_less_wide_wide()
         {
             double2x3 a0 = double2x3(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774);
@@ -194,7 +194,7 @@ public static void double2x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_less_wide_scalar()
         {
             double2x3 a0 = double2x3(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879);
@@ -218,7 +218,7 @@ public static void double2x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -242,7 +242,7 @@ public static void double2x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_greater_wide_wide()
         {
             double2x3 a0 = double2x3(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479);
@@ -266,7 +266,7 @@ public static void double2x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_greater_wide_scalar()
         {
             double2x3 a0 = double2x3(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809);
@@ -290,7 +290,7 @@ public static void double2x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -314,7 +314,7 @@ public static void double2x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_less_equal_wide_wide()
         {
             double2x3 a0 = double2x3(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475);
@@ -338,7 +338,7 @@ public static void double2x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_less_equal_wide_scalar()
         {
             double2x3 a0 = double2x3(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136);
@@ -362,7 +362,7 @@ public static void double2x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -386,7 +386,7 @@ public static void double2x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_greater_equal_wide_wide()
         {
             double2x3 a0 = double2x3(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193);
@@ -410,7 +410,7 @@ public static void double2x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_greater_equal_wide_scalar()
         {
             double2x3 a0 = double2x3(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976);
@@ -434,7 +434,7 @@ public static void double2x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -458,7 +458,7 @@ public static void double2x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_add_wide_wide()
         {
             double2x3 a0 = double2x3(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056);
@@ -482,7 +482,7 @@ public static void double2x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_add_wide_scalar()
         {
             double2x3 a0 = double2x3(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166);
@@ -506,7 +506,7 @@ public static void double2x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -530,7 +530,7 @@ public static void double2x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_sub_wide_wide()
         {
             double2x3 a0 = double2x3(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053);
@@ -554,7 +554,7 @@ public static void double2x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_sub_wide_scalar()
         {
             double2x3 a0 = double2x3(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896);
@@ -578,7 +578,7 @@ public static void double2x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -602,7 +602,7 @@ public static void double2x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_mul_wide_wide()
         {
             double2x3 a0 = double2x3(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747);
@@ -626,7 +626,7 @@ public static void double2x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_mul_wide_scalar()
         {
             double2x3 a0 = double2x3(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229);
@@ -650,7 +650,7 @@ public static void double2x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -674,7 +674,7 @@ public static void double2x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_div_wide_wide()
         {
             double2x3 a0 = double2x3(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758);
@@ -698,7 +698,7 @@ public static void double2x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_div_wide_scalar()
         {
             double2x3 a0 = double2x3(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509);
@@ -722,7 +722,7 @@ public static void double2x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -746,7 +746,7 @@ public static void double2x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_mod_wide_wide()
         {
             double2x3 a0 = double2x3(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406);
@@ -770,7 +770,7 @@ public static void double2x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_mod_wide_scalar()
         {
             double2x3 a0 = double2x3(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221);
@@ -794,7 +794,7 @@ public static void double2x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -818,7 +818,7 @@ public static void double2x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_plus()
         {
             double2x3 a0 = double2x3(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287);
@@ -838,7 +838,7 @@ public static void double2x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_neg()
         {
             double2x3 a0 = double2x3(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605);
@@ -858,7 +858,7 @@ public static void double2x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_prefix_inc()
         {
             double2x3 a0 = double2x3(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198);
@@ -878,7 +878,7 @@ public static void double2x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_postfix_inc()
         {
             double2x3 a0 = double2x3(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219);
@@ -898,7 +898,7 @@ public static void double2x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_prefix_dec()
         {
             double2x3 a0 = double2x3(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339);
@@ -918,7 +918,7 @@ public static void double2x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x3_operator_postfix_dec()
         {
             double2x3 a0 = double2x3(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231);
@@ -938,7 +938,7 @@ public static void double2x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void double2x3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new double2x3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestDouble2x4.gen.cs b/src/Tests/Tests/Shared/TestDouble2x4.gen.cs
index aac05afe..822a43bb 100644
--- a/src/Tests/Tests/Shared/TestDouble2x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble2x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble2x4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_zero()
         {
             TestUtils.AreEqual(0.0, double2x4.zero.c0.x);
@@ -28,7 +28,7 @@ public static void double2x4_zero()
             TestUtils.AreEqual(0.0, double2x4.zero.c3.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_equal_wide_wide()
         {
             double2x4 a0 = double2x4(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889);
@@ -52,7 +52,7 @@ public static void double2x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_equal_wide_scalar()
         {
             double2x4 a0 = double2x4(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405);
@@ -76,7 +76,7 @@ public static void double2x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -100,7 +100,7 @@ public static void double2x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_not_equal_wide_wide()
         {
             double2x4 a0 = double2x4(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895);
@@ -124,7 +124,7 @@ public static void double2x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_not_equal_wide_scalar()
         {
             double2x4 a0 = double2x4(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842);
@@ -148,7 +148,7 @@ public static void double2x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -172,7 +172,7 @@ public static void double2x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_less_wide_wide()
         {
             double2x4 a0 = double2x4(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259);
@@ -196,7 +196,7 @@ public static void double2x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_less_wide_scalar()
         {
             double2x4 a0 = double2x4(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061);
@@ -220,7 +220,7 @@ public static void double2x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -244,7 +244,7 @@ public static void double2x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_greater_wide_wide()
         {
             double2x4 a0 = double2x4(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484);
@@ -268,7 +268,7 @@ public static void double2x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_greater_wide_scalar()
         {
             double2x4 a0 = double2x4(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972);
@@ -292,7 +292,7 @@ public static void double2x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -316,7 +316,7 @@ public static void double2x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_less_equal_wide_wide()
         {
             double2x4 a0 = double2x4(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232);
@@ -340,7 +340,7 @@ public static void double2x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_less_equal_wide_scalar()
         {
             double2x4 a0 = double2x4(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582);
@@ -364,7 +364,7 @@ public static void double2x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -388,7 +388,7 @@ public static void double2x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_greater_equal_wide_wide()
         {
             double2x4 a0 = double2x4(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265);
@@ -412,7 +412,7 @@ public static void double2x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_greater_equal_wide_scalar()
         {
             double2x4 a0 = double2x4(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838);
@@ -436,7 +436,7 @@ public static void double2x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -460,7 +460,7 @@ public static void double2x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_add_wide_wide()
         {
             double2x4 a0 = double2x4(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656);
@@ -484,7 +484,7 @@ public static void double2x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_add_wide_scalar()
         {
             double2x4 a0 = double2x4(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454);
@@ -508,7 +508,7 @@ public static void double2x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -532,7 +532,7 @@ public static void double2x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_sub_wide_wide()
         {
             double2x4 a0 = double2x4(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537);
@@ -556,7 +556,7 @@ public static void double2x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_sub_wide_scalar()
         {
             double2x4 a0 = double2x4(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965);
@@ -580,7 +580,7 @@ public static void double2x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -604,7 +604,7 @@ public static void double2x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_mul_wide_wide()
         {
             double2x4 a0 = double2x4(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149);
@@ -628,7 +628,7 @@ public static void double2x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_mul_wide_scalar()
         {
             double2x4 a0 = double2x4(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334);
@@ -652,7 +652,7 @@ public static void double2x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -676,7 +676,7 @@ public static void double2x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_div_wide_wide()
         {
             double2x4 a0 = double2x4(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537);
@@ -700,7 +700,7 @@ public static void double2x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_div_wide_scalar()
         {
             double2x4 a0 = double2x4(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539);
@@ -724,7 +724,7 @@ public static void double2x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -748,7 +748,7 @@ public static void double2x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_mod_wide_wide()
         {
             double2x4 a0 = double2x4(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664);
@@ -772,7 +772,7 @@ public static void double2x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_mod_wide_scalar()
         {
             double2x4 a0 = double2x4(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243);
@@ -796,7 +796,7 @@ public static void double2x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -820,7 +820,7 @@ public static void double2x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_plus()
         {
             double2x4 a0 = double2x4(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488);
@@ -840,7 +840,7 @@ public static void double2x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_neg()
         {
             double2x4 a0 = double2x4(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581);
@@ -860,7 +860,7 @@ public static void double2x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_prefix_inc()
         {
             double2x4 a0 = double2x4(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267);
@@ -880,7 +880,7 @@ public static void double2x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_postfix_inc()
         {
             double2x4 a0 = double2x4(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271);
@@ -900,7 +900,7 @@ public static void double2x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_prefix_dec()
         {
             double2x4 a0 = double2x4(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558);
@@ -920,7 +920,7 @@ public static void double2x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2x4_operator_postfix_dec()
         {
             double2x4 a0 = double2x4(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568);
@@ -940,7 +940,7 @@ public static void double2x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void double2x4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new double2x4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestDouble3.gen.cs b/src/Tests/Tests/Shared/TestDouble3.gen.cs
index cc53ddbf..2bd08a5d 100644
--- a/src/Tests/Tests/Shared/TestDouble3.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_zero()
         {
             TestUtils.AreEqual(0.0, double3.zero.x);
@@ -23,7 +23,7 @@ public static void double3_zero()
             TestUtils.AreEqual(0.0, double3.zero.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_constructor()
         {
             double3 a = new double3(1, 2, 3);
@@ -32,7 +32,7 @@ public static void double3_constructor()
             TestUtils.AreEqual(3, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_scalar_constructor()
         {
             double3 a = new double3(17.0);
@@ -41,7 +41,7 @@ public static void double3_scalar_constructor()
             TestUtils.AreEqual(17.0, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_static_constructor()
         {
             double3 a = double3(1, 2, 3);
@@ -50,7 +50,7 @@ public static void double3_static_constructor()
             TestUtils.AreEqual(3, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_static_scalar_constructor()
         {
             double3 a = double3(17.0);
@@ -59,7 +59,7 @@ public static void double3_static_scalar_constructor()
             TestUtils.AreEqual(17.0, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_equal_wide_wide()
         {
             double3 a0 = double3(492.15758275061728, -495.20632027797694, 227.45765195947968);
@@ -83,7 +83,7 @@ public static void double3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_equal_wide_scalar()
         {
             double3 a0 = double3(-303.2300766926399, 451.52631327674089, -253.65587413201848);
@@ -107,7 +107,7 @@ public static void double3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -131,7 +131,7 @@ public static void double3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_not_equal_wide_wide()
         {
             double3 a0 = double3(430.8425316432689, 104.69001798736394, 225.80243478799355);
@@ -155,7 +155,7 @@ public static void double3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_not_equal_wide_scalar()
         {
             double3 a0 = double3(-16.914588697680529, 168.83411486858233, -462.71352145760949);
@@ -179,7 +179,7 @@ public static void double3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -203,7 +203,7 @@ public static void double3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_less_wide_wide()
         {
             double3 a0 = double3(196.84256825076534, 336.40979997087732, 251.96372115424072);
@@ -227,7 +227,7 @@ public static void double3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_less_wide_scalar()
         {
             double3 a0 = double3(-132.05731708000292, -192.46500477216438, -66.834607870706634);
@@ -251,7 +251,7 @@ public static void double3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -275,7 +275,7 @@ public static void double3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_greater_wide_wide()
         {
             double3 a0 = double3(483.50140141113729, 310.81563415695712, 106.9661896726891);
@@ -299,7 +299,7 @@ public static void double3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_greater_wide_scalar()
         {
             double3 a0 = double3(64.317918092160426, -397.70346445483318, 431.87690826499693);
@@ -323,7 +323,7 @@ public static void double3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -347,7 +347,7 @@ public static void double3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_less_equal_wide_wide()
         {
             double3 a0 = double3(-438.52313753521219, 210.48942837980087, 4.8773329280677444);
@@ -371,7 +371,7 @@ public static void double3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_less_equal_wide_scalar()
         {
             double3 a0 = double3(193.4958237118534, 168.91555197952107, -313.9930695565385);
@@ -395,7 +395,7 @@ public static void double3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -419,7 +419,7 @@ public static void double3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_greater_equal_wide_wide()
         {
             double3 a0 = double3(-507.92858409692, 504.49748181947393, -385.43449205226938);
@@ -443,7 +443,7 @@ public static void double3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_greater_equal_wide_scalar()
         {
             double3 a0 = double3(465.15218732559686, -424.8860745024337, -209.22109685150025);
@@ -467,7 +467,7 @@ public static void double3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -491,7 +491,7 @@ public static void double3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_add_wide_wide()
         {
             double3 a0 = double3(506.12905263627374, -501.77980803967444, 420.08479638587903);
@@ -515,7 +515,7 @@ public static void double3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_add_wide_scalar()
         {
             double3 a0 = double3(-194.51420387742769, 338.54838696985894, 246.97140252169754);
@@ -539,7 +539,7 @@ public static void double3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -563,7 +563,7 @@ public static void double3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_sub_wide_wide()
         {
             double3 a0 = double3(160.4922617229131, 11.223957305412682, 359.20010607279846);
@@ -587,7 +587,7 @@ public static void double3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_sub_wide_scalar()
         {
             double3 a0 = double3(207.38960108877609, 248.45773684627272, -384.82393211164697);
@@ -611,7 +611,7 @@ public static void double3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -635,7 +635,7 @@ public static void double3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_mul_wide_wide()
         {
             double3 a0 = double3(-482.71381710596097, -407.29348559272171, 137.70058995937029);
@@ -659,7 +659,7 @@ public static void double3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_mul_wide_scalar()
         {
             double3 a0 = double3(-96.318821236639678, -277.14229239017811, -239.93690191951436);
@@ -683,7 +683,7 @@ public static void double3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -707,7 +707,7 @@ public static void double3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_div_wide_wide()
         {
             double3 a0 = double3(-353.13144390337703, -102.79985456485292, 51.319128298814917);
@@ -731,7 +731,7 @@ public static void double3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_div_wide_scalar()
         {
             double3 a0 = double3(171.34242184988341, 0.10338377957384637, 57.888263967767443);
@@ -755,7 +755,7 @@ public static void double3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -779,7 +779,7 @@ public static void double3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_mod_wide_wide()
         {
             double3 a0 = double3(-388.81249422059045, 181.68118842955732, -167.07872470052854);
@@ -803,7 +803,7 @@ public static void double3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_mod_wide_scalar()
         {
             double3 a0 = double3(-244.49962889612635, -211.81931958525411, -145.92677576184587);
@@ -827,7 +827,7 @@ public static void double3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -851,7 +851,7 @@ public static void double3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_plus()
         {
             double3 a0 = double3(-418.82956357432045, -405.79894823851015, -34.041791216489742);
@@ -871,7 +871,7 @@ public static void double3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_neg()
         {
             double3 a0 = double3(148.46174890755753, -467.12267873581624, 132.04719954917539);
@@ -891,7 +891,7 @@ public static void double3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_prefix_inc()
         {
             double3 a0 = double3(-139.84208137348389, -56.743654039103376, -381.955324589254);
@@ -911,7 +911,7 @@ public static void double3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_postfix_inc()
         {
             double3 a0 = double3(-396.6697396695007, 511.20749378167443, 249.11127030528678);
@@ -931,7 +931,7 @@ public static void double3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_prefix_dec()
         {
             double3 a0 = double3(123.12869626056806, 256.8437465433235, 156.33078844674435);
@@ -951,7 +951,7 @@ public static void double3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_operator_postfix_dec()
         {
             double3 a0 = double3(379.68831723727669, 302.69287814884115, -176.07134040448409);
@@ -971,7 +971,7 @@ public static void double3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_shuffle_result_1()
         {
             double3 a = double3(0, 1, 2);
@@ -985,7 +985,7 @@ public static void double3_shuffle_result_1()
             TestUtils.AreEqual((5), shuffle(a, b, ShuffleComponent.RightZ));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_shuffle_result_2()
         {
             double3 a = double3(0, 1, 2);
@@ -1009,7 +1009,7 @@ public static void double3_shuffle_result_2()
             TestUtils.AreEqual(double2(1, 2), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_shuffle_result_3()
         {
             double3 a = double3(0, 1, 2);
@@ -1033,7 +1033,7 @@ public static void double3_shuffle_result_3()
             TestUtils.AreEqual(double3(4, 0, 5), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_shuffle_result_4()
         {
             double3 a = double3(0, 1, 2);
@@ -1057,7 +1057,7 @@ public static void double3_shuffle_result_4()
             TestUtils.AreEqual(double4(2, 5, 0, 4), shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightY));
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void double3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new double3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestDouble3x2.gen.cs b/src/Tests/Tests/Shared/TestDouble3x2.gen.cs
index 382e68b6..bbfffa3a 100644
--- a/src/Tests/Tests/Shared/TestDouble3x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble3x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble3x2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_zero()
         {
             TestUtils.AreEqual(0.0, double3x2.zero.c0.x);
@@ -26,7 +26,7 @@ public static void double3x2_zero()
             TestUtils.AreEqual(0.0, double3x2.zero.c1.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_equal_wide_wide()
         {
             double3x2 a0 = double3x2(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749);
@@ -50,7 +50,7 @@ public static void double3x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_equal_wide_scalar()
         {
             double3x2 a0 = double3x2(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315);
@@ -74,7 +74,7 @@ public static void double3x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -98,7 +98,7 @@ public static void double3x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_not_equal_wide_wide()
         {
             double3x2 a0 = double3x2(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379);
@@ -122,7 +122,7 @@ public static void double3x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_not_equal_wide_scalar()
         {
             double3x2 a0 = double3x2(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959);
@@ -146,7 +146,7 @@ public static void double3x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -170,7 +170,7 @@ public static void double3x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_less_wide_wide()
         {
             double3x2 a0 = double3x2(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774);
@@ -194,7 +194,7 @@ public static void double3x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_less_wide_scalar()
         {
             double3x2 a0 = double3x2(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879);
@@ -218,7 +218,7 @@ public static void double3x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -242,7 +242,7 @@ public static void double3x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_greater_wide_wide()
         {
             double3x2 a0 = double3x2(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479);
@@ -266,7 +266,7 @@ public static void double3x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_greater_wide_scalar()
         {
             double3x2 a0 = double3x2(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809);
@@ -290,7 +290,7 @@ public static void double3x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -314,7 +314,7 @@ public static void double3x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_less_equal_wide_wide()
         {
             double3x2 a0 = double3x2(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475);
@@ -338,7 +338,7 @@ public static void double3x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_less_equal_wide_scalar()
         {
             double3x2 a0 = double3x2(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136);
@@ -362,7 +362,7 @@ public static void double3x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -386,7 +386,7 @@ public static void double3x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_greater_equal_wide_wide()
         {
             double3x2 a0 = double3x2(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193);
@@ -410,7 +410,7 @@ public static void double3x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_greater_equal_wide_scalar()
         {
             double3x2 a0 = double3x2(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976);
@@ -434,7 +434,7 @@ public static void double3x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -458,7 +458,7 @@ public static void double3x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_add_wide_wide()
         {
             double3x2 a0 = double3x2(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056);
@@ -482,7 +482,7 @@ public static void double3x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_add_wide_scalar()
         {
             double3x2 a0 = double3x2(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166);
@@ -506,7 +506,7 @@ public static void double3x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -530,7 +530,7 @@ public static void double3x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_sub_wide_wide()
         {
             double3x2 a0 = double3x2(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053);
@@ -554,7 +554,7 @@ public static void double3x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_sub_wide_scalar()
         {
             double3x2 a0 = double3x2(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896);
@@ -578,7 +578,7 @@ public static void double3x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -602,7 +602,7 @@ public static void double3x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_mul_wide_wide()
         {
             double3x2 a0 = double3x2(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747);
@@ -626,7 +626,7 @@ public static void double3x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_mul_wide_scalar()
         {
             double3x2 a0 = double3x2(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229);
@@ -650,7 +650,7 @@ public static void double3x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -674,7 +674,7 @@ public static void double3x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_div_wide_wide()
         {
             double3x2 a0 = double3x2(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758);
@@ -698,7 +698,7 @@ public static void double3x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_div_wide_scalar()
         {
             double3x2 a0 = double3x2(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509);
@@ -722,7 +722,7 @@ public static void double3x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -746,7 +746,7 @@ public static void double3x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_mod_wide_wide()
         {
             double3x2 a0 = double3x2(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406);
@@ -770,7 +770,7 @@ public static void double3x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_mod_wide_scalar()
         {
             double3x2 a0 = double3x2(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221);
@@ -794,7 +794,7 @@ public static void double3x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -818,7 +818,7 @@ public static void double3x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_plus()
         {
             double3x2 a0 = double3x2(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287);
@@ -838,7 +838,7 @@ public static void double3x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_neg()
         {
             double3x2 a0 = double3x2(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605);
@@ -858,7 +858,7 @@ public static void double3x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_prefix_inc()
         {
             double3x2 a0 = double3x2(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198);
@@ -878,7 +878,7 @@ public static void double3x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_postfix_inc()
         {
             double3x2 a0 = double3x2(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219);
@@ -898,7 +898,7 @@ public static void double3x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_prefix_dec()
         {
             double3x2 a0 = double3x2(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339);
@@ -918,7 +918,7 @@ public static void double3x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x2_operator_postfix_dec()
         {
             double3x2 a0 = double3x2(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231);
@@ -938,7 +938,7 @@ public static void double3x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void double3x2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new double3x2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestDouble3x3.gen.cs b/src/Tests/Tests/Shared/TestDouble3x3.gen.cs
index 56364618..aca1ba86 100644
--- a/src/Tests/Tests/Shared/TestDouble3x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble3x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble3x3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_zero()
         {
             TestUtils.AreEqual(0.0, double3x3.zero.c0.x);
@@ -29,7 +29,7 @@ public static void double3x3_zero()
             TestUtils.AreEqual(0.0, double3x3.zero.c2.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_identity()
         {
             TestUtils.AreEqual(1.0, double3x3.identity.c0.x);
@@ -43,7 +43,7 @@ public static void double3x3_identity()
             TestUtils.AreEqual(1.0, double3x3.identity.c2.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_equal_wide_wide()
         {
             double3x3 a0 = double3x3(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889, 163.23210890741655);
@@ -67,7 +67,7 @@ public static void double3x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_equal_wide_scalar()
         {
             double3x3 a0 = double3x3(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405, -57.477391031327386);
@@ -91,7 +91,7 @@ public static void double3x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -115,7 +115,7 @@ public static void double3x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_not_equal_wide_wide()
         {
             double3x3 a0 = double3x3(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895, -203.30197606016975);
@@ -139,7 +139,7 @@ public static void double3x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_not_equal_wide_scalar()
         {
             double3x3 a0 = double3x3(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842, -386.61117595555783);
@@ -163,7 +163,7 @@ public static void double3x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -187,7 +187,7 @@ public static void double3x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_less_wide_wide()
         {
             double3x3 a0 = double3x3(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259, 164.67880662003472);
@@ -211,7 +211,7 @@ public static void double3x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_less_wide_scalar()
         {
             double3x3 a0 = double3x3(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061, -20.452607402788772);
@@ -235,7 +235,7 @@ public static void double3x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -259,7 +259,7 @@ public static void double3x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_greater_wide_wide()
         {
             double3x3 a0 = double3x3(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484, -24.740548383789417);
@@ -283,7 +283,7 @@ public static void double3x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_greater_wide_scalar()
         {
             double3x3 a0 = double3x3(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972, -405.78459210218148);
@@ -307,7 +307,7 @@ public static void double3x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -331,7 +331,7 @@ public static void double3x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_less_equal_wide_wide()
         {
             double3x3 a0 = double3x3(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232, 458.53029153241323);
@@ -355,7 +355,7 @@ public static void double3x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_less_equal_wide_scalar()
         {
             double3x3 a0 = double3x3(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582, -1.3577692515020203);
@@ -379,7 +379,7 @@ public static void double3x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -403,7 +403,7 @@ public static void double3x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_greater_equal_wide_wide()
         {
             double3x3 a0 = double3x3(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265, 456.96878573716094);
@@ -427,7 +427,7 @@ public static void double3x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_greater_equal_wide_scalar()
         {
             double3x3 a0 = double3x3(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838, 393.27804846003562);
@@ -451,7 +451,7 @@ public static void double3x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -475,7 +475,7 @@ public static void double3x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_add_wide_wide()
         {
             double3x3 a0 = double3x3(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656, 462.41368148402012);
@@ -499,7 +499,7 @@ public static void double3x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_add_wide_scalar()
         {
             double3x3 a0 = double3x3(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454, -242.1187475855084);
@@ -523,7 +523,7 @@ public static void double3x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -547,7 +547,7 @@ public static void double3x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_sub_wide_wide()
         {
             double3x3 a0 = double3x3(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537, 317.70681944382693);
@@ -571,7 +571,7 @@ public static void double3x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_sub_wide_scalar()
         {
             double3x3 a0 = double3x3(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965, 480.85798738936796);
@@ -595,7 +595,7 @@ public static void double3x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -619,7 +619,7 @@ public static void double3x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_mul_wide_wide()
         {
             double3x3 a0 = double3x3(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149, 45.868758938214114);
@@ -643,7 +643,7 @@ public static void double3x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_mul_wide_scalar()
         {
             double3x3 a0 = double3x3(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334, -338.29248658674419);
@@ -667,7 +667,7 @@ public static void double3x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -691,7 +691,7 @@ public static void double3x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_div_wide_wide()
         {
             double3x3 a0 = double3x3(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537, -237.69456326109105);
@@ -715,7 +715,7 @@ public static void double3x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_div_wide_scalar()
         {
             double3x3 a0 = double3x3(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539, 146.46688110496234);
@@ -739,7 +739,7 @@ public static void double3x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -763,7 +763,7 @@ public static void double3x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_mod_wide_wide()
         {
             double3x3 a0 = double3x3(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664, 335.27101413126616);
@@ -787,7 +787,7 @@ public static void double3x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_mod_wide_scalar()
         {
             double3x3 a0 = double3x3(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243, 335.16613046041039);
@@ -811,7 +811,7 @@ public static void double3x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -835,7 +835,7 @@ public static void double3x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_plus()
         {
             double3x3 a0 = double3x3(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488, -386.059833944803);
@@ -855,7 +855,7 @@ public static void double3x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_neg()
         {
             double3x3 a0 = double3x3(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581, -299.09338893512887);
@@ -875,7 +875,7 @@ public static void double3x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_prefix_inc()
         {
             double3x3 a0 = double3x3(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267, 362.21273939787068);
@@ -895,7 +895,7 @@ public static void double3x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_postfix_inc()
         {
             double3x3 a0 = double3x3(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271, 167.85212691493894);
@@ -915,7 +915,7 @@ public static void double3x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_prefix_dec()
         {
             double3x3 a0 = double3x3(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558, 125.10963517292851);
@@ -935,7 +935,7 @@ public static void double3x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x3_operator_postfix_dec()
         {
             double3x3 a0 = double3x3(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568, -27.889220489137415);
@@ -955,7 +955,7 @@ public static void double3x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void double3x3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new double3x3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestDouble3x4.gen.cs b/src/Tests/Tests/Shared/TestDouble3x4.gen.cs
index c54ef5be..48170ecf 100644
--- a/src/Tests/Tests/Shared/TestDouble3x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble3x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble3x4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_zero()
         {
             TestUtils.AreEqual(0.0, double3x4.zero.c0.x);
@@ -32,7 +32,7 @@ public static void double3x4_zero()
             TestUtils.AreEqual(0.0, double3x4.zero.c3.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_equal_wide_wide()
         {
             double3x4 a0 = double3x4(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889, 163.23210890741655, -165.27101071424363, 470.87767980568003, -423.94255967808078);
@@ -56,7 +56,7 @@ public static void double3x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_equal_wide_scalar()
         {
             double3x4 a0 = double3x4(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405, -57.477391031327386, -182.04973968400139, 406.51375861024189, 370.88599866017978);
@@ -80,7 +80,7 @@ public static void double3x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -104,7 +104,7 @@ public static void double3x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_not_equal_wide_wide()
         {
             double3x4 a0 = double3x4(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895, -203.30197606016975, -505.76325368590807, 162.17220623892365, 1.1561973100324394);
@@ -128,7 +128,7 @@ public static void double3x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_not_equal_wide_scalar()
         {
             double3x4 a0 = double3x4(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842, -386.61117595555783, -281.02101362916687, -270.26885593601912, -403.96372313236992);
@@ -152,7 +152,7 @@ public static void double3x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -176,7 +176,7 @@ public static void double3x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_less_wide_wide()
         {
             double3x4 a0 = double3x4(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259, 164.67880662003472, -350.94487516532877, 3.84143662631584, 125.40972024081725);
@@ -200,7 +200,7 @@ public static void double3x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_less_wide_scalar()
         {
             double3x4 a0 = double3x4(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061, -20.452607402788772, 225.29148517609178, 307.48418607725023, 274.01523292903562);
@@ -224,7 +224,7 @@ public static void double3x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -248,7 +248,7 @@ public static void double3x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_greater_wide_wide()
         {
             double3x4 a0 = double3x4(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484, -24.740548383789417, 319.78262701620474, -120.15856581561201, -289.00857962714906);
@@ -272,7 +272,7 @@ public static void double3x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_greater_wide_scalar()
         {
             double3x4 a0 = double3x4(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972, -405.78459210218148, 171.56538661362856, -241.80727326209063, 333.57817498481745);
@@ -296,7 +296,7 @@ public static void double3x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -320,7 +320,7 @@ public static void double3x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_less_equal_wide_wide()
         {
             double3x4 a0 = double3x4(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232, 458.53029153241323, -294.06474675520542, 23.622613679441884, -34.284056441059363);
@@ -344,7 +344,7 @@ public static void double3x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_less_equal_wide_scalar()
         {
             double3x4 a0 = double3x4(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582, -1.3577692515020203, -268.89945591096739, 398.9919504593089, -471.253072242836);
@@ -368,7 +368,7 @@ public static void double3x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -392,7 +392,7 @@ public static void double3x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_greater_equal_wide_wide()
         {
             double3x4 a0 = double3x4(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265, 456.96878573716094, -211.01015506079892, 182.41135391146474, -53.596053863687473);
@@ -416,7 +416,7 @@ public static void double3x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_greater_equal_wide_scalar()
         {
             double3x4 a0 = double3x4(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838, 393.27804846003562, -315.70155086913218, 441.0115565923096, -509.78156757251435);
@@ -440,7 +440,7 @@ public static void double3x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -464,7 +464,7 @@ public static void double3x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_add_wide_wide()
         {
             double3x4 a0 = double3x4(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656, 462.41368148402012, -46.178705952213477, 401.17006296718966, -454.12414643453627);
@@ -488,7 +488,7 @@ public static void double3x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_add_wide_scalar()
         {
             double3x4 a0 = double3x4(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454, -242.1187475855084, 82.50134495762245, 6.7993848355483806, -484.69981287638649);
@@ -512,7 +512,7 @@ public static void double3x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -536,7 +536,7 @@ public static void double3x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_sub_wide_wide()
         {
             double3x4 a0 = double3x4(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537, 317.70681944382693, 447.0604133303558, -489.07414482956477, -230.00838218909149);
@@ -560,7 +560,7 @@ public static void double3x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_sub_wide_scalar()
         {
             double3x4 a0 = double3x4(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965, 480.85798738936796, 16.338193185784917, -366.86545269883493, -35.523088233323335);
@@ -584,7 +584,7 @@ public static void double3x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -608,7 +608,7 @@ public static void double3x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_mul_wide_wide()
         {
             double3x4 a0 = double3x4(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149, 45.868758938214114, 363.32610266438041, -328.11893692990714, -471.02307413100408);
@@ -632,7 +632,7 @@ public static void double3x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_mul_wide_scalar()
         {
             double3x4 a0 = double3x4(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334, -338.29248658674419, 53.796284939067618, 243.75734459783757, 135.35469991311186);
@@ -656,7 +656,7 @@ public static void double3x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -680,7 +680,7 @@ public static void double3x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_div_wide_wide()
         {
             double3x4 a0 = double3x4(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537, -237.69456326109105, -432.54687496300176, 200.26549181727012, 361.44157068871039);
@@ -704,7 +704,7 @@ public static void double3x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_div_wide_scalar()
         {
             double3x4 a0 = double3x4(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539, 146.46688110496234, -499.84355687529012, 58.686315802245531, -453.20579859856787);
@@ -728,7 +728,7 @@ public static void double3x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -752,7 +752,7 @@ public static void double3x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_mod_wide_wide()
         {
             double3x4 a0 = double3x4(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664, 335.27101413126616, -503.60851668920765, 191.02251848532933, 289.74269379756538);
@@ -776,7 +776,7 @@ public static void double3x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_mod_wide_scalar()
         {
             double3x4 a0 = double3x4(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243, 335.16613046041039, 101.70649032560482, 319.47152033423606, -285.40231646476423);
@@ -800,7 +800,7 @@ public static void double3x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -824,7 +824,7 @@ public static void double3x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_plus()
         {
             double3x4 a0 = double3x4(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488, -386.059833944803, 4.9544198536101476, -418.64524932328857, 504.47483062393724);
@@ -844,7 +844,7 @@ public static void double3x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_neg()
         {
             double3x4 a0 = double3x4(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581, -299.09338893512887, -383.01406377508027, 407.70980305583669, 168.73550351370852);
@@ -864,7 +864,7 @@ public static void double3x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_prefix_inc()
         {
             double3x4 a0 = double3x4(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267, 362.21273939787068, 401.614830919362, 130.90919429199266, -450.23016402229212);
@@ -884,7 +884,7 @@ public static void double3x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_postfix_inc()
         {
             double3x4 a0 = double3x4(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271, 167.85212691493894, 147.94395048354932, -326.10758486674524, 41.033564825092185);
@@ -904,7 +904,7 @@ public static void double3x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_prefix_dec()
         {
             double3x4 a0 = double3x4(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558, 125.10963517292851, 469.8447313112415, 45.536655685648611, 376.04684680329956);
@@ -924,7 +924,7 @@ public static void double3x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3x4_operator_postfix_dec()
         {
             double3x4 a0 = double3x4(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568, -27.889220489137415, -100.76183824462902, 156.14034969924967, 479.94519613680677);
@@ -944,7 +944,7 @@ public static void double3x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void double3x4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new double3x4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestDouble4.gen.cs b/src/Tests/Tests/Shared/TestDouble4.gen.cs
index 2d907e2a..6dec9e23 100644
--- a/src/Tests/Tests/Shared/TestDouble4.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_zero()
         {
             TestUtils.AreEqual(0.0, double4.zero.x);
@@ -24,7 +24,7 @@ public static void double4_zero()
             TestUtils.AreEqual(0.0, double4.zero.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_constructor()
         {
             double4 a = new double4(1, 2, 3, 4);
@@ -34,7 +34,7 @@ public static void double4_constructor()
             TestUtils.AreEqual(4, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_scalar_constructor()
         {
             double4 a = new double4(17.0);
@@ -44,7 +44,7 @@ public static void double4_scalar_constructor()
             TestUtils.AreEqual(17.0, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_static_constructor()
         {
             double4 a = double4(1, 2, 3, 4);
@@ -54,7 +54,7 @@ public static void double4_static_constructor()
             TestUtils.AreEqual(4, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_static_scalar_constructor()
         {
             double4 a = double4(17.0);
@@ -64,7 +64,7 @@ public static void double4_static_scalar_constructor()
             TestUtils.AreEqual(17.0, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_equal_wide_wide()
         {
             double4 a0 = double4(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182);
@@ -88,7 +88,7 @@ public static void double4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_equal_wide_scalar()
         {
             double4 a0 = double4(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995);
@@ -112,7 +112,7 @@ public static void double4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -136,7 +136,7 @@ public static void double4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_not_equal_wide_wide()
         {
             double4 a0 = double4(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048);
@@ -160,7 +160,7 @@ public static void double4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_not_equal_wide_scalar()
         {
             double4 a0 = double4(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137);
@@ -184,7 +184,7 @@ public static void double4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -208,7 +208,7 @@ public static void double4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_less_wide_wide()
         {
             double4 a0 = double4(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963);
@@ -232,7 +232,7 @@ public static void double4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_less_wide_scalar()
         {
             double4 a0 = double4(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561);
@@ -256,7 +256,7 @@ public static void double4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -280,7 +280,7 @@ public static void double4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_greater_wide_wide()
         {
             double4 a0 = double4(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671);
@@ -304,7 +304,7 @@ public static void double4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_greater_wide_scalar()
         {
             double4 a0 = double4(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157);
@@ -328,7 +328,7 @@ public static void double4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -352,7 +352,7 @@ public static void double4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_less_equal_wide_wide()
         {
             double4 a0 = double4(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857);
@@ -376,7 +376,7 @@ public static void double4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_less_equal_wide_scalar()
         {
             double4 a0 = double4(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292);
@@ -400,7 +400,7 @@ public static void double4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -424,7 +424,7 @@ public static void double4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_greater_equal_wide_wide()
         {
             double4 a0 = double4(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784);
@@ -448,7 +448,7 @@ public static void double4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_greater_equal_wide_scalar()
         {
             double4 a0 = double4(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356);
@@ -472,7 +472,7 @@ public static void double4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -496,7 +496,7 @@ public static void double4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_add_wide_wide()
         {
             double4 a0 = double4(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274);
@@ -520,7 +520,7 @@ public static void double4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_add_wide_scalar()
         {
             double4 a0 = double4(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752);
@@ -544,7 +544,7 @@ public static void double4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -568,7 +568,7 @@ public static void double4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_sub_wide_wide()
         {
             double4 a0 = double4(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311);
@@ -592,7 +592,7 @@ public static void double4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_sub_wide_scalar()
         {
             double4 a0 = double4(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506);
@@ -616,7 +616,7 @@ public static void double4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -640,7 +640,7 @@ public static void double4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_mul_wide_wide()
         {
             double4 a0 = double4(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182);
@@ -664,7 +664,7 @@ public static void double4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_mul_wide_scalar()
         {
             double4 a0 = double4(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409);
@@ -688,7 +688,7 @@ public static void double4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -712,7 +712,7 @@ public static void double4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_div_wide_wide()
         {
             double4 a0 = double4(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176);
@@ -736,7 +736,7 @@ public static void double4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_div_wide_scalar()
         {
             double4 a0 = double4(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078);
@@ -760,7 +760,7 @@ public static void double4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -784,7 +784,7 @@ public static void double4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_mod_wide_wide()
         {
             double4 a0 = double4(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813);
@@ -808,7 +808,7 @@ public static void double4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_mod_wide_scalar()
         {
             double4 a0 = double4(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672);
@@ -832,7 +832,7 @@ public static void double4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -856,7 +856,7 @@ public static void double4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_plus()
         {
             double4 a0 = double4(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421);
@@ -876,7 +876,7 @@ public static void double4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_neg()
         {
             double4 a0 = double4(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463);
@@ -896,7 +896,7 @@ public static void double4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_prefix_inc()
         {
             double4 a0 = double4(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962);
@@ -916,7 +916,7 @@ public static void double4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_postfix_inc()
         {
             double4 a0 = double4(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153);
@@ -936,7 +936,7 @@ public static void double4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_prefix_dec()
         {
             double4 a0 = double4(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563);
@@ -956,7 +956,7 @@ public static void double4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_operator_postfix_dec()
         {
             double4 a0 = double4(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962);
@@ -976,7 +976,7 @@ public static void double4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_shuffle_result_1()
         {
             double4 a = double4(0, 1, 2, 3);
@@ -992,7 +992,7 @@ public static void double4_shuffle_result_1()
             TestUtils.AreEqual((7), shuffle(a, b, ShuffleComponent.RightW));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_shuffle_result_2()
         {
             double4 a = double4(0, 1, 2, 3);
@@ -1016,7 +1016,7 @@ public static void double4_shuffle_result_2()
             TestUtils.AreEqual(double2(1, 3), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_shuffle_result_3()
         {
             double4 a = double4(0, 1, 2, 3);
@@ -1040,7 +1040,7 @@ public static void double4_shuffle_result_3()
             TestUtils.AreEqual(double3(5, 1, 7), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_shuffle_result_4()
         {
             double4 a = double4(0, 1, 2, 3);
@@ -1064,7 +1064,7 @@ public static void double4_shuffle_result_4()
             TestUtils.AreEqual(double4(3, 7, 1, 5), shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.LeftY, ShuffleComponent.RightY));
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void double4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new double4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestDouble4x2.gen.cs b/src/Tests/Tests/Shared/TestDouble4x2.gen.cs
index 0e02dc29..112a10df 100644
--- a/src/Tests/Tests/Shared/TestDouble4x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble4x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble4x2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_zero()
         {
             TestUtils.AreEqual(0.0, double4x2.zero.c0.x);
@@ -28,7 +28,7 @@ public static void double4x2_zero()
             TestUtils.AreEqual(0.0, double4x2.zero.c1.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_equal_wide_wide()
         {
             double4x2 a0 = double4x2(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889);
@@ -52,7 +52,7 @@ public static void double4x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_equal_wide_scalar()
         {
             double4x2 a0 = double4x2(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405);
@@ -76,7 +76,7 @@ public static void double4x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -100,7 +100,7 @@ public static void double4x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_not_equal_wide_wide()
         {
             double4x2 a0 = double4x2(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895);
@@ -124,7 +124,7 @@ public static void double4x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_not_equal_wide_scalar()
         {
             double4x2 a0 = double4x2(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842);
@@ -148,7 +148,7 @@ public static void double4x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -172,7 +172,7 @@ public static void double4x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_less_wide_wide()
         {
             double4x2 a0 = double4x2(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259);
@@ -196,7 +196,7 @@ public static void double4x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_less_wide_scalar()
         {
             double4x2 a0 = double4x2(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061);
@@ -220,7 +220,7 @@ public static void double4x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -244,7 +244,7 @@ public static void double4x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_greater_wide_wide()
         {
             double4x2 a0 = double4x2(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484);
@@ -268,7 +268,7 @@ public static void double4x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_greater_wide_scalar()
         {
             double4x2 a0 = double4x2(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972);
@@ -292,7 +292,7 @@ public static void double4x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -316,7 +316,7 @@ public static void double4x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_less_equal_wide_wide()
         {
             double4x2 a0 = double4x2(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232);
@@ -340,7 +340,7 @@ public static void double4x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_less_equal_wide_scalar()
         {
             double4x2 a0 = double4x2(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582);
@@ -364,7 +364,7 @@ public static void double4x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -388,7 +388,7 @@ public static void double4x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_greater_equal_wide_wide()
         {
             double4x2 a0 = double4x2(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265);
@@ -412,7 +412,7 @@ public static void double4x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_greater_equal_wide_scalar()
         {
             double4x2 a0 = double4x2(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838);
@@ -436,7 +436,7 @@ public static void double4x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -460,7 +460,7 @@ public static void double4x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_add_wide_wide()
         {
             double4x2 a0 = double4x2(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656);
@@ -484,7 +484,7 @@ public static void double4x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_add_wide_scalar()
         {
             double4x2 a0 = double4x2(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454);
@@ -508,7 +508,7 @@ public static void double4x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -532,7 +532,7 @@ public static void double4x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_sub_wide_wide()
         {
             double4x2 a0 = double4x2(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537);
@@ -556,7 +556,7 @@ public static void double4x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_sub_wide_scalar()
         {
             double4x2 a0 = double4x2(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965);
@@ -580,7 +580,7 @@ public static void double4x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -604,7 +604,7 @@ public static void double4x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_mul_wide_wide()
         {
             double4x2 a0 = double4x2(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149);
@@ -628,7 +628,7 @@ public static void double4x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_mul_wide_scalar()
         {
             double4x2 a0 = double4x2(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334);
@@ -652,7 +652,7 @@ public static void double4x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -676,7 +676,7 @@ public static void double4x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_div_wide_wide()
         {
             double4x2 a0 = double4x2(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537);
@@ -700,7 +700,7 @@ public static void double4x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_div_wide_scalar()
         {
             double4x2 a0 = double4x2(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539);
@@ -724,7 +724,7 @@ public static void double4x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -748,7 +748,7 @@ public static void double4x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_mod_wide_wide()
         {
             double4x2 a0 = double4x2(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664);
@@ -772,7 +772,7 @@ public static void double4x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_mod_wide_scalar()
         {
             double4x2 a0 = double4x2(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243);
@@ -796,7 +796,7 @@ public static void double4x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -820,7 +820,7 @@ public static void double4x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_plus()
         {
             double4x2 a0 = double4x2(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488);
@@ -840,7 +840,7 @@ public static void double4x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_neg()
         {
             double4x2 a0 = double4x2(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581);
@@ -860,7 +860,7 @@ public static void double4x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_prefix_inc()
         {
             double4x2 a0 = double4x2(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267);
@@ -880,7 +880,7 @@ public static void double4x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_postfix_inc()
         {
             double4x2 a0 = double4x2(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271);
@@ -900,7 +900,7 @@ public static void double4x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_prefix_dec()
         {
             double4x2 a0 = double4x2(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558);
@@ -920,7 +920,7 @@ public static void double4x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x2_operator_postfix_dec()
         {
             double4x2 a0 = double4x2(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568);
@@ -940,7 +940,7 @@ public static void double4x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void double4x2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new double4x2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestDouble4x3.gen.cs b/src/Tests/Tests/Shared/TestDouble4x3.gen.cs
index 66d6e952..90982950 100644
--- a/src/Tests/Tests/Shared/TestDouble4x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble4x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble4x3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_zero()
         {
             TestUtils.AreEqual(0.0, double4x3.zero.c0.x);
@@ -32,7 +32,7 @@ public static void double4x3_zero()
             TestUtils.AreEqual(0.0, double4x3.zero.c2.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_equal_wide_wide()
         {
             double4x3 a0 = double4x3(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889, 163.23210890741655, -165.27101071424363, 470.87767980568003, -423.94255967808078);
@@ -56,7 +56,7 @@ public static void double4x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_equal_wide_scalar()
         {
             double4x3 a0 = double4x3(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405, -57.477391031327386, -182.04973968400139, 406.51375861024189, 370.88599866017978);
@@ -80,7 +80,7 @@ public static void double4x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -104,7 +104,7 @@ public static void double4x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_not_equal_wide_wide()
         {
             double4x3 a0 = double4x3(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895, -203.30197606016975, -505.76325368590807, 162.17220623892365, 1.1561973100324394);
@@ -128,7 +128,7 @@ public static void double4x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_not_equal_wide_scalar()
         {
             double4x3 a0 = double4x3(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842, -386.61117595555783, -281.02101362916687, -270.26885593601912, -403.96372313236992);
@@ -152,7 +152,7 @@ public static void double4x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -176,7 +176,7 @@ public static void double4x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_less_wide_wide()
         {
             double4x3 a0 = double4x3(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259, 164.67880662003472, -350.94487516532877, 3.84143662631584, 125.40972024081725);
@@ -200,7 +200,7 @@ public static void double4x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_less_wide_scalar()
         {
             double4x3 a0 = double4x3(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061, -20.452607402788772, 225.29148517609178, 307.48418607725023, 274.01523292903562);
@@ -224,7 +224,7 @@ public static void double4x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -248,7 +248,7 @@ public static void double4x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_greater_wide_wide()
         {
             double4x3 a0 = double4x3(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484, -24.740548383789417, 319.78262701620474, -120.15856581561201, -289.00857962714906);
@@ -272,7 +272,7 @@ public static void double4x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_greater_wide_scalar()
         {
             double4x3 a0 = double4x3(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972, -405.78459210218148, 171.56538661362856, -241.80727326209063, 333.57817498481745);
@@ -296,7 +296,7 @@ public static void double4x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -320,7 +320,7 @@ public static void double4x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_less_equal_wide_wide()
         {
             double4x3 a0 = double4x3(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232, 458.53029153241323, -294.06474675520542, 23.622613679441884, -34.284056441059363);
@@ -344,7 +344,7 @@ public static void double4x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_less_equal_wide_scalar()
         {
             double4x3 a0 = double4x3(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582, -1.3577692515020203, -268.89945591096739, 398.9919504593089, -471.253072242836);
@@ -368,7 +368,7 @@ public static void double4x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -392,7 +392,7 @@ public static void double4x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_greater_equal_wide_wide()
         {
             double4x3 a0 = double4x3(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265, 456.96878573716094, -211.01015506079892, 182.41135391146474, -53.596053863687473);
@@ -416,7 +416,7 @@ public static void double4x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_greater_equal_wide_scalar()
         {
             double4x3 a0 = double4x3(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838, 393.27804846003562, -315.70155086913218, 441.0115565923096, -509.78156757251435);
@@ -440,7 +440,7 @@ public static void double4x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -464,7 +464,7 @@ public static void double4x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_add_wide_wide()
         {
             double4x3 a0 = double4x3(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656, 462.41368148402012, -46.178705952213477, 401.17006296718966, -454.12414643453627);
@@ -488,7 +488,7 @@ public static void double4x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_add_wide_scalar()
         {
             double4x3 a0 = double4x3(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454, -242.1187475855084, 82.50134495762245, 6.7993848355483806, -484.69981287638649);
@@ -512,7 +512,7 @@ public static void double4x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -536,7 +536,7 @@ public static void double4x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_sub_wide_wide()
         {
             double4x3 a0 = double4x3(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537, 317.70681944382693, 447.0604133303558, -489.07414482956477, -230.00838218909149);
@@ -560,7 +560,7 @@ public static void double4x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_sub_wide_scalar()
         {
             double4x3 a0 = double4x3(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965, 480.85798738936796, 16.338193185784917, -366.86545269883493, -35.523088233323335);
@@ -584,7 +584,7 @@ public static void double4x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -608,7 +608,7 @@ public static void double4x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_mul_wide_wide()
         {
             double4x3 a0 = double4x3(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149, 45.868758938214114, 363.32610266438041, -328.11893692990714, -471.02307413100408);
@@ -632,7 +632,7 @@ public static void double4x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_mul_wide_scalar()
         {
             double4x3 a0 = double4x3(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334, -338.29248658674419, 53.796284939067618, 243.75734459783757, 135.35469991311186);
@@ -656,7 +656,7 @@ public static void double4x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -680,7 +680,7 @@ public static void double4x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_div_wide_wide()
         {
             double4x3 a0 = double4x3(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537, -237.69456326109105, -432.54687496300176, 200.26549181727012, 361.44157068871039);
@@ -704,7 +704,7 @@ public static void double4x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_div_wide_scalar()
         {
             double4x3 a0 = double4x3(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539, 146.46688110496234, -499.84355687529012, 58.686315802245531, -453.20579859856787);
@@ -728,7 +728,7 @@ public static void double4x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -752,7 +752,7 @@ public static void double4x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_mod_wide_wide()
         {
             double4x3 a0 = double4x3(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664, 335.27101413126616, -503.60851668920765, 191.02251848532933, 289.74269379756538);
@@ -776,7 +776,7 @@ public static void double4x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_mod_wide_scalar()
         {
             double4x3 a0 = double4x3(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243, 335.16613046041039, 101.70649032560482, 319.47152033423606, -285.40231646476423);
@@ -800,7 +800,7 @@ public static void double4x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -824,7 +824,7 @@ public static void double4x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_plus()
         {
             double4x3 a0 = double4x3(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488, -386.059833944803, 4.9544198536101476, -418.64524932328857, 504.47483062393724);
@@ -844,7 +844,7 @@ public static void double4x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_neg()
         {
             double4x3 a0 = double4x3(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581, -299.09338893512887, -383.01406377508027, 407.70980305583669, 168.73550351370852);
@@ -864,7 +864,7 @@ public static void double4x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_prefix_inc()
         {
             double4x3 a0 = double4x3(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267, 362.21273939787068, 401.614830919362, 130.90919429199266, -450.23016402229212);
@@ -884,7 +884,7 @@ public static void double4x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_postfix_inc()
         {
             double4x3 a0 = double4x3(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271, 167.85212691493894, 147.94395048354932, -326.10758486674524, 41.033564825092185);
@@ -904,7 +904,7 @@ public static void double4x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_prefix_dec()
         {
             double4x3 a0 = double4x3(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558, 125.10963517292851, 469.8447313112415, 45.536655685648611, 376.04684680329956);
@@ -924,7 +924,7 @@ public static void double4x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x3_operator_postfix_dec()
         {
             double4x3 a0 = double4x3(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568, -27.889220489137415, -100.76183824462902, 156.14034969924967, 479.94519613680677);
@@ -944,7 +944,7 @@ public static void double4x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void double4x3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new double4x3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestDouble4x4.gen.cs b/src/Tests/Tests/Shared/TestDouble4x4.gen.cs
index bd638617..8c982bb3 100644
--- a/src/Tests/Tests/Shared/TestDouble4x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble4x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble4x4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_zero()
         {
             TestUtils.AreEqual(0.0, double4x4.zero.c0.x);
@@ -36,7 +36,7 @@ public static void double4x4_zero()
             TestUtils.AreEqual(0.0, double4x4.zero.c3.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_identity()
         {
             TestUtils.AreEqual(1.0, double4x4.identity.c0.x);
@@ -57,7 +57,7 @@ public static void double4x4_identity()
             TestUtils.AreEqual(1.0, double4x4.identity.c3.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_equal_wide_wide()
         {
             double4x4 a0 = double4x4(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889, 163.23210890741655, -165.27101071424363, 470.87767980568003, -423.94255967808078, 109.63436918595539, 462.69031283943468, -335.38147727371262, 357.23446934168896);
@@ -81,7 +81,7 @@ public static void double4x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_equal_wide_scalar()
         {
             double4x4 a0 = double4x4(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405, -57.477391031327386, -182.04973968400139, 406.51375861024189, 370.88599866017978, -172.03530629539642, 455.40001198993991, -11.338988547836891, 363.93823044557973);
@@ -105,7 +105,7 @@ public static void double4x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -129,7 +129,7 @@ public static void double4x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_not_equal_wide_wide()
         {
             double4x4 a0 = double4x4(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895, -203.30197606016975, -505.76325368590807, 162.17220623892365, 1.1561973100324394, 65.662074358045174, 102.78780250567377, 172.93008120960098, 26.621009123800832);
@@ -153,7 +153,7 @@ public static void double4x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_not_equal_wide_scalar()
         {
             double4x4 a0 = double4x4(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842, -386.61117595555783, -281.02101362916687, -270.26885593601912, -403.96372313236992, -269.80570877241234, 299.65422763473089, -71.750904831919286, -432.75573917513515);
@@ -177,7 +177,7 @@ public static void double4x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -201,7 +201,7 @@ public static void double4x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_less_wide_wide()
         {
             double4x4 a0 = double4x4(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259, 164.67880662003472, -350.94487516532877, 3.84143662631584, 125.40972024081725, -111.12994127680076, 70.005523475820951, 448.19828173527412, -419.98711200244122);
@@ -225,7 +225,7 @@ public static void double4x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_less_wide_scalar()
         {
             double4x4 a0 = double4x4(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061, -20.452607402788772, 225.29148517609178, 307.48418607725023, 274.01523292903562, 373.54965584983563, 398.52368301829495, 105.0301654827922, -58.010895994496934);
@@ -249,7 +249,7 @@ public static void double4x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -273,7 +273,7 @@ public static void double4x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_greater_wide_wide()
         {
             double4x4 a0 = double4x4(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484, -24.740548383789417, 319.78262701620474, -120.15856581561201, -289.00857962714906, 455.85146662958505, 144.70691139283917, 63.931990891663304, -285.68304099034663);
@@ -297,7 +297,7 @@ public static void double4x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_greater_wide_scalar()
         {
             double4x4 a0 = double4x4(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972, -405.78459210218148, 171.56538661362856, -241.80727326209063, 333.57817498481745, 370.27919524269146, -413.70138116073861, -356.5923551789449, -353.03129522550444);
@@ -321,7 +321,7 @@ public static void double4x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -345,7 +345,7 @@ public static void double4x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_less_equal_wide_wide()
         {
             double4x4 a0 = double4x4(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232, 458.53029153241323, -294.06474675520542, 23.622613679441884, -34.284056441059363, 149.736484835733, -418.8866781754823, -197.50252899783783, -88.2055118494693);
@@ -369,7 +369,7 @@ public static void double4x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_less_equal_wide_scalar()
         {
             double4x4 a0 = double4x4(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582, -1.3577692515020203, -268.89945591096739, 398.9919504593089, -471.253072242836, -264.93778264938749, 82.258299150624453, 11.246050124636895, 424.7040156911612);
@@ -393,7 +393,7 @@ public static void double4x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -417,7 +417,7 @@ public static void double4x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_greater_equal_wide_wide()
         {
             double4x4 a0 = double4x4(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265, 456.96878573716094, -211.01015506079892, 182.41135391146474, -53.596053863687473, -309.57021608463032, -136.02249127999994, 280.73629082401112, -96.9958942388165);
@@ -441,7 +441,7 @@ public static void double4x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_greater_equal_wide_scalar()
         {
             double4x4 a0 = double4x4(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838, 393.27804846003562, -315.70155086913218, 441.0115565923096, -509.78156757251435, -36.994287269652943, 494.82028865014217, -164.97393830352183, -466.12009046325466);
@@ -465,7 +465,7 @@ public static void double4x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -489,7 +489,7 @@ public static void double4x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_add_wide_wide()
         {
             double4x4 a0 = double4x4(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656, 462.41368148402012, -46.178705952213477, 401.17006296718966, -454.12414643453627, 69.195687564646732, -177.95734485329939, 299.60415544156183, 340.7048587001417);
@@ -513,7 +513,7 @@ public static void double4x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_add_wide_scalar()
         {
             double4x4 a0 = double4x4(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454, -242.1187475855084, 82.50134495762245, 6.7993848355483806, -484.69981287638649, -188.26501068298938, -213.52673087526426, -267.78430688929944, 189.25996669999324);
@@ -537,7 +537,7 @@ public static void double4x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -561,7 +561,7 @@ public static void double4x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_sub_wide_wide()
         {
             double4x4 a0 = double4x4(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537, 317.70681944382693, 447.0604133303558, -489.07414482956477, -230.00838218909149, 24.875419389864192, 366.61447136784648, -107.3741567634857, -219.0081404275299);
@@ -585,7 +585,7 @@ public static void double4x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_sub_wide_scalar()
         {
             double4x4 a0 = double4x4(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965, 480.85798738936796, 16.338193185784917, -366.86545269883493, -35.523088233323335, 349.39776460705218, 439.07729336203886, 490.2222661870635, 195.02405104181923);
@@ -609,7 +609,7 @@ public static void double4x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -633,7 +633,7 @@ public static void double4x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_mul_wide_wide()
         {
             double4x4 a0 = double4x4(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149, 45.868758938214114, 363.32610266438041, -328.11893692990714, -471.02307413100408, -262.68257415605831, -379.26274674910246, -374.09058182970182, 481.44738720424812);
@@ -657,7 +657,7 @@ public static void double4x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_mul_wide_scalar()
         {
             double4x4 a0 = double4x4(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334, -338.29248658674419, 53.796284939067618, 243.75734459783757, 135.35469991311186, -207.35010275959507, -383.93960946795517, -31.425238862366086, 42.676120539510634);
@@ -681,7 +681,7 @@ public static void double4x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -705,7 +705,7 @@ public static void double4x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_div_wide_wide()
         {
             double4x4 a0 = double4x4(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537, -237.69456326109105, -432.54687496300176, 200.26549181727012, 361.44157068871039, -416.22613234828509, -450.01919362042992, -273.49744594911925, -286.90817011841955);
@@ -729,7 +729,7 @@ public static void double4x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_div_wide_scalar()
         {
             double4x4 a0 = double4x4(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539, 146.46688110496234, -499.84355687529012, 58.686315802245531, -453.20579859856787, -205.03382143985192, 481.73814247629514, 464.47907159499778, -293.46349753693841);
@@ -753,7 +753,7 @@ public static void double4x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -777,7 +777,7 @@ public static void double4x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_mod_wide_wide()
         {
             double4x4 a0 = double4x4(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664, 335.27101413126616, -503.60851668920765, 191.02251848532933, 289.74269379756538, -124.03371745163281, 259.27395761165485, -274.35845030208975, -140.03080398404541);
@@ -801,7 +801,7 @@ public static void double4x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_mod_wide_scalar()
         {
             double4x4 a0 = double4x4(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243, 335.16613046041039, 101.70649032560482, 319.47152033423606, -285.40231646476423, -355.84685985923136, 259.37800061860025, -330.87193957477433, -284.34358109363518);
@@ -825,7 +825,7 @@ public static void double4x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -849,7 +849,7 @@ public static void double4x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_plus()
         {
             double4x4 a0 = double4x4(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488, -386.059833944803, 4.9544198536101476, -418.64524932328857, 504.47483062393724, -170.74650843941907, 439.55937572920664, -478.74939916969714, 116.40075665172219);
@@ -869,7 +869,7 @@ public static void double4x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_neg()
         {
             double4x4 a0 = double4x4(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581, -299.09338893512887, -383.01406377508027, 407.70980305583669, 168.73550351370852, 466.44152829909763, 171.90249474900895, -280.55831564616335, -78.85761622286293);
@@ -889,7 +889,7 @@ public static void double4x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_prefix_inc()
         {
             double4x4 a0 = double4x4(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267, 362.21273939787068, 401.614830919362, 130.90919429199266, -450.23016402229212, 243.54693114177644, 46.19202735190845, -41.497298975241051, 299.18547000511808);
@@ -909,7 +909,7 @@ public static void double4x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_postfix_inc()
         {
             double4x4 a0 = double4x4(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271, 167.85212691493894, 147.94395048354932, -326.10758486674524, 41.033564825092185, 128.5304239394751, 73.155582223625629, -60.132380275117384, -446.22976490772783);
@@ -929,7 +929,7 @@ public static void double4x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_prefix_dec()
         {
             double4x4 a0 = double4x4(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558, 125.10963517292851, 469.8447313112415, 45.536655685648611, 376.04684680329956, -363.07547991493504, -22.028951416736902, 248.79012667797042, 168.0950144120003);
@@ -949,7 +949,7 @@ public static void double4x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4x4_operator_postfix_dec()
         {
             double4x4 a0 = double4x4(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568, -27.889220489137415, -100.76183824462902, 156.14034969924967, 479.94519613680677, -200.30429491787419, -445.0269393609031, 407.42034907239508, 327.67032519340069);
@@ -969,7 +969,7 @@ public static void double4x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void double4x4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new double4x4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestFloat2.gen.cs b/src/Tests/Tests/Shared/TestFloat2.gen.cs
index b14288cc..acacdb83 100644
--- a/src/Tests/Tests/Shared/TestFloat2.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat2.gen.cs
@@ -15,14 +15,14 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_zero()
         {
             TestUtils.AreEqual(0.0f, float2.zero.x);
             TestUtils.AreEqual(0.0f, float2.zero.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_constructor()
         {
             float2 a = new float2(1, 2);
@@ -30,7 +30,7 @@ public static void float2_constructor()
             TestUtils.AreEqual(2, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_scalar_constructor()
         {
             float2 a = new float2(17.0f);
@@ -38,7 +38,7 @@ public static void float2_scalar_constructor()
             TestUtils.AreEqual(17.0f, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_static_constructor()
         {
             float2 a = float2(1, 2);
@@ -46,7 +46,7 @@ public static void float2_static_constructor()
             TestUtils.AreEqual(2, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_static_scalar_constructor()
         {
             float2 a = float2(17.0f);
@@ -54,7 +54,7 @@ public static void float2_static_scalar_constructor()
             TestUtils.AreEqual(17.0f, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_equal_wide_wide()
         {
             float2 a0 = float2(492.1576f, -495.206329f);
@@ -78,7 +78,7 @@ public static void float2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_equal_wide_scalar()
         {
             float2 a0 = float2(-303.230072f, 451.5263f);
@@ -102,7 +102,7 @@ public static void float2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -126,7 +126,7 @@ public static void float2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_not_equal_wide_wide()
         {
             float2 a0 = float2(430.842529f, 104.69f);
@@ -150,7 +150,7 @@ public static void float2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_not_equal_wide_scalar()
         {
             float2 a0 = float2(-16.9145813f, 168.8341f);
@@ -174,7 +174,7 @@ public static void float2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -198,7 +198,7 @@ public static void float2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_less_wide_wide()
         {
             float2 a0 = float2(196.84259f, 336.4098f);
@@ -222,7 +222,7 @@ public static void float2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_less_wide_scalar()
         {
             float2 a0 = float2(-132.057312f, -192.465f);
@@ -246,7 +246,7 @@ public static void float2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -270,7 +270,7 @@ public static void float2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_greater_wide_wide()
         {
             float2 a0 = float2(483.5014f, 310.8156f);
@@ -294,7 +294,7 @@ public static void float2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_greater_wide_scalar()
         {
             float2 a0 = float2(64.31793f, -397.703461f);
@@ -318,7 +318,7 @@ public static void float2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -342,7 +342,7 @@ public static void float2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_less_equal_wide_wide()
         {
             float2 a0 = float2(-438.523132f, 210.489441f);
@@ -366,7 +366,7 @@ public static void float2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_less_equal_wide_scalar()
         {
             float2 a0 = float2(193.49585f, 168.915527f);
@@ -390,7 +390,7 @@ public static void float2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -414,7 +414,7 @@ public static void float2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_greater_equal_wide_wide()
         {
             float2 a0 = float2(-507.9286f, 504.4975f);
@@ -438,7 +438,7 @@ public static void float2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_greater_equal_wide_scalar()
         {
             float2 a0 = float2(465.152161f, -424.886078f);
@@ -462,7 +462,7 @@ public static void float2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -486,7 +486,7 @@ public static void float2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_add_wide_wide()
         {
             float2 a0 = float2(506.129028f, -501.779816f);
@@ -510,7 +510,7 @@ public static void float2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_add_wide_scalar()
         {
             float2 a0 = float2(-194.514191f, 338.5484f);
@@ -534,7 +534,7 @@ public static void float2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -558,7 +558,7 @@ public static void float2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_sub_wide_wide()
         {
             float2 a0 = float2(160.492249f, 11.223938f);
@@ -582,7 +582,7 @@ public static void float2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_sub_wide_scalar()
         {
             float2 a0 = float2(207.389587f, 248.457764f);
@@ -606,7 +606,7 @@ public static void float2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -630,7 +630,7 @@ public static void float2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_mul_wide_wide()
         {
             float2 a0 = float2(-482.7138f, -407.2935f);
@@ -654,7 +654,7 @@ public static void float2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_mul_wide_scalar()
         {
             float2 a0 = float2(-96.31882f, -277.142273f);
@@ -678,7 +678,7 @@ public static void float2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -702,7 +702,7 @@ public static void float2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_div_wide_wide()
         {
             float2 a0 = float2(-353.131439f, -102.799866f);
@@ -726,7 +726,7 @@ public static void float2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_div_wide_scalar()
         {
             float2 a0 = float2(171.3424f, 0.103393555f);
@@ -750,7 +750,7 @@ public static void float2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -774,7 +774,7 @@ public static void float2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_mod_wide_wide()
         {
             float2 a0 = float2(-388.8125f, 181.681213f);
@@ -798,7 +798,7 @@ public static void float2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_mod_wide_scalar()
         {
             float2 a0 = float2(-244.499634f, -211.8193f);
@@ -822,7 +822,7 @@ public static void float2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -846,7 +846,7 @@ public static void float2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_plus()
         {
             float2 a0 = float2(-418.829559f, -405.79895f);
@@ -866,7 +866,7 @@ public static void float2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_neg()
         {
             float2 a0 = float2(148.461731f, -467.122681f);
@@ -886,7 +886,7 @@ public static void float2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_prefix_inc()
         {
             float2 a0 = float2(-139.842072f, -56.7436523f);
@@ -906,7 +906,7 @@ public static void float2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_postfix_inc()
         {
             float2 a0 = float2(-396.669739f, 511.20752f);
@@ -926,7 +926,7 @@ public static void float2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_prefix_dec()
         {
             float2 a0 = float2(123.128723f, 256.84375f);
@@ -946,7 +946,7 @@ public static void float2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_operator_postfix_dec()
         {
             float2 a0 = float2(379.6883f, 302.692871f);
@@ -966,7 +966,7 @@ public static void float2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_shuffle_result_1()
         {
             float2 a = float2(0, 1);
@@ -978,7 +978,7 @@ public static void float2_shuffle_result_1()
             TestUtils.AreEqual((3), shuffle(a, b, ShuffleComponent.RightY));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_shuffle_result_2()
         {
             float2 a = float2(0, 1);
@@ -1002,7 +1002,7 @@ public static void float2_shuffle_result_2()
             TestUtils.AreEqual(float2(3, 3), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_shuffle_result_3()
         {
             float2 a = float2(0, 1);
@@ -1026,7 +1026,7 @@ public static void float2_shuffle_result_3()
             TestUtils.AreEqual(float3(3, 1, 1), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_shuffle_result_4()
         {
             float2 a = float2(0, 1);
@@ -1050,7 +1050,7 @@ public static void float2_shuffle_result_4()
             TestUtils.AreEqual(float4(2, 0, 0, 0), shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX));
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void float2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new float2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestFloat2x2.gen.cs b/src/Tests/Tests/Shared/TestFloat2x2.gen.cs
index 5b818da7..c5594164 100644
--- a/src/Tests/Tests/Shared/TestFloat2x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat2x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat2x2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_zero()
         {
             TestUtils.AreEqual(0.0f, float2x2.zero.c0.x);
@@ -24,7 +24,7 @@ public static void float2x2_zero()
             TestUtils.AreEqual(0.0f, float2x2.zero.c1.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_identity()
         {
             TestUtils.AreEqual(1.0f, float2x2.identity.c0.x);
@@ -33,7 +33,7 @@ public static void float2x2_identity()
             TestUtils.AreEqual(1.0f, float2x2.identity.c1.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_equal_wide_wide()
         {
             float2x2 a0 = float2x2(492.1576f, -495.206329f, 227.457642f, -147.374054f);
@@ -57,7 +57,7 @@ public static void float2x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_equal_wide_scalar()
         {
             float2x2 a0 = float2x2(-303.230072f, 451.5263f, -253.655884f, -105.203644f);
@@ -81,7 +81,7 @@ public static void float2x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -105,7 +105,7 @@ public static void float2x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_not_equal_wide_wide()
         {
             float2x2 a0 = float2x2(430.842529f, 104.69f, 225.802429f, -310.5702f);
@@ -129,7 +129,7 @@ public static void float2x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_not_equal_wide_scalar()
         {
             float2x2 a0 = float2x2(-16.9145813f, 168.8341f, -462.713531f, 130.307739f);
@@ -153,7 +153,7 @@ public static void float2x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -177,7 +177,7 @@ public static void float2x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_less_wide_wide()
         {
             float2x2 a0 = float2x2(196.84259f, 336.4098f, 251.963745f, 257.655945f);
@@ -201,7 +201,7 @@ public static void float2x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_less_wide_scalar()
         {
             float2x2 a0 = float2x2(-132.057312f, -192.465f, -66.8345947f, -379.017517f);
@@ -225,7 +225,7 @@ public static void float2x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -249,7 +249,7 @@ public static void float2x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_greater_wide_wide()
         {
             float2x2 a0 = float2x2(483.5014f, 310.8156f, 106.966187f, 295.7353f);
@@ -273,7 +273,7 @@ public static void float2x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_greater_wide_scalar()
         {
             float2x2 a0 = float2x2(64.31793f, -397.703461f, 431.8769f, 85.703f);
@@ -297,7 +297,7 @@ public static void float2x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -321,7 +321,7 @@ public static void float2x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_less_equal_wide_wide()
         {
             float2x2 a0 = float2x2(-438.523132f, 210.489441f, 4.87731934f, -137.297943f);
@@ -345,7 +345,7 @@ public static void float2x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_less_equal_wide_scalar()
         {
             float2x2 a0 = float2x2(193.49585f, 168.915527f, -313.993073f, 81.8269653f);
@@ -369,7 +369,7 @@ public static void float2x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -393,7 +393,7 @@ public static void float2x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_greater_equal_wide_wide()
         {
             float2x2 a0 = float2x2(-507.9286f, 504.4975f, -385.4345f, -262.323425f);
@@ -417,7 +417,7 @@ public static void float2x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_greater_equal_wide_scalar()
         {
             float2x2 a0 = float2x2(465.152161f, -424.886078f, -209.2211f, 58.7798462f);
@@ -441,7 +441,7 @@ public static void float2x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -465,7 +465,7 @@ public static void float2x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_add_wide_wide()
         {
             float2x2 a0 = float2x2(506.129028f, -501.779816f, 420.084778f, -186.032074f);
@@ -489,7 +489,7 @@ public static void float2x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_add_wide_scalar()
         {
             float2x2 a0 = float2x2(-194.514191f, 338.5484f, 246.971375f, 100.510925f);
@@ -513,7 +513,7 @@ public static void float2x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -537,7 +537,7 @@ public static void float2x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_sub_wide_wide()
         {
             float2x2 a0 = float2x2(160.492249f, 11.223938f, 359.200134f, -498.2283f);
@@ -561,7 +561,7 @@ public static void float2x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_sub_wide_scalar()
         {
             float2x2 a0 = float2x2(207.389587f, 248.457764f, -384.8239f, -205.344757f);
@@ -585,7 +585,7 @@ public static void float2x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -609,7 +609,7 @@ public static void float2x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_mul_wide_wide()
         {
             float2x2 a0 = float2x2(-482.7138f, -407.2935f, 137.700562f, 208.541138f);
@@ -633,7 +633,7 @@ public static void float2x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_mul_wide_scalar()
         {
             float2x2 a0 = float2x2(-96.31882f, -277.142273f, -239.93689f, 509.531433f);
@@ -657,7 +657,7 @@ public static void float2x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -681,7 +681,7 @@ public static void float2x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_div_wide_wide()
         {
             float2x2 a0 = float2x2(-353.131439f, -102.799866f, 51.3191528f, -191.871674f);
@@ -705,7 +705,7 @@ public static void float2x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_div_wide_scalar()
         {
             float2x2 a0 = float2x2(171.3424f, 0.103393555f, 57.8882446f, -256.130737f);
@@ -729,7 +729,7 @@ public static void float2x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -753,7 +753,7 @@ public static void float2x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_mod_wide_wide()
         {
             float2x2 a0 = float2x2(-388.8125f, 181.681213f, -167.078735f, 432.820129f);
@@ -777,7 +777,7 @@ public static void float2x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_mod_wide_scalar()
         {
             float2x2 a0 = float2x2(-244.499634f, -211.8193f, -145.926788f, -304.9182f);
@@ -801,7 +801,7 @@ public static void float2x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -825,7 +825,7 @@ public static void float2x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_plus()
         {
             float2x2 a0 = float2x2(-418.829559f, -405.79895f, -34.04178f, 236.999268f);
@@ -845,7 +845,7 @@ public static void float2x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_neg()
         {
             float2x2 a0 = float2x2(148.461731f, -467.122681f, 132.04718f, 183.522644f);
@@ -865,7 +865,7 @@ public static void float2x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_prefix_inc()
         {
             float2x2 a0 = float2x2(-139.842072f, -56.7436523f, -381.955322f, 509.796326f);
@@ -885,7 +885,7 @@ public static void float2x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_postfix_inc()
         {
             float2x2 a0 = float2x2(-396.669739f, 511.20752f, 249.111267f, -128.817322f);
@@ -905,7 +905,7 @@ public static void float2x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_prefix_dec()
         {
             float2x2 a0 = float2x2(123.128723f, 256.84375f, 156.330811f, 461.737427f);
@@ -925,7 +925,7 @@ public static void float2x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_operator_postfix_dec()
         {
             float2x2 a0 = float2x2(379.6883f, 302.692871f, -176.07135f, -291.2527f);
@@ -945,7 +945,7 @@ public static void float2x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void float2x2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new float2x2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestFloat2x3.gen.cs b/src/Tests/Tests/Shared/TestFloat2x3.gen.cs
index 8a93998c..e619dc0d 100644
--- a/src/Tests/Tests/Shared/TestFloat2x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat2x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat2x3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_zero()
         {
             TestUtils.AreEqual(0.0f, float2x3.zero.c0.x);
@@ -26,7 +26,7 @@ public static void float2x3_zero()
             TestUtils.AreEqual(0.0f, float2x3.zero.c2.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_equal_wide_wide()
         {
             float2x3 a0 = float2x3(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f);
@@ -50,7 +50,7 @@ public static void float2x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_equal_wide_scalar()
         {
             float2x3 a0 = float2x3(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f);
@@ -74,7 +74,7 @@ public static void float2x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -98,7 +98,7 @@ public static void float2x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_not_equal_wide_wide()
         {
             float2x3 a0 = float2x3(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f);
@@ -122,7 +122,7 @@ public static void float2x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_not_equal_wide_scalar()
         {
             float2x3 a0 = float2x3(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f);
@@ -146,7 +146,7 @@ public static void float2x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -170,7 +170,7 @@ public static void float2x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_less_wide_wide()
         {
             float2x3 a0 = float2x3(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f);
@@ -194,7 +194,7 @@ public static void float2x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_less_wide_scalar()
         {
             float2x3 a0 = float2x3(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f);
@@ -218,7 +218,7 @@ public static void float2x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -242,7 +242,7 @@ public static void float2x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_greater_wide_wide()
         {
             float2x3 a0 = float2x3(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f);
@@ -266,7 +266,7 @@ public static void float2x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_greater_wide_scalar()
         {
             float2x3 a0 = float2x3(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f);
@@ -290,7 +290,7 @@ public static void float2x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -314,7 +314,7 @@ public static void float2x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_less_equal_wide_wide()
         {
             float2x3 a0 = float2x3(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f);
@@ -338,7 +338,7 @@ public static void float2x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_less_equal_wide_scalar()
         {
             float2x3 a0 = float2x3(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f);
@@ -362,7 +362,7 @@ public static void float2x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -386,7 +386,7 @@ public static void float2x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_greater_equal_wide_wide()
         {
             float2x3 a0 = float2x3(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f);
@@ -410,7 +410,7 @@ public static void float2x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_greater_equal_wide_scalar()
         {
             float2x3 a0 = float2x3(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f);
@@ -434,7 +434,7 @@ public static void float2x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -458,7 +458,7 @@ public static void float2x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_add_wide_wide()
         {
             float2x3 a0 = float2x3(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f);
@@ -482,7 +482,7 @@ public static void float2x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_add_wide_scalar()
         {
             float2x3 a0 = float2x3(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f);
@@ -506,7 +506,7 @@ public static void float2x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -530,7 +530,7 @@ public static void float2x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_sub_wide_wide()
         {
             float2x3 a0 = float2x3(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f);
@@ -554,7 +554,7 @@ public static void float2x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_sub_wide_scalar()
         {
             float2x3 a0 = float2x3(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f);
@@ -578,7 +578,7 @@ public static void float2x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -602,7 +602,7 @@ public static void float2x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_mul_wide_wide()
         {
             float2x3 a0 = float2x3(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f);
@@ -626,7 +626,7 @@ public static void float2x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_mul_wide_scalar()
         {
             float2x3 a0 = float2x3(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f);
@@ -650,7 +650,7 @@ public static void float2x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -674,7 +674,7 @@ public static void float2x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_div_wide_wide()
         {
             float2x3 a0 = float2x3(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f);
@@ -698,7 +698,7 @@ public static void float2x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_div_wide_scalar()
         {
             float2x3 a0 = float2x3(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f);
@@ -722,7 +722,7 @@ public static void float2x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -746,7 +746,7 @@ public static void float2x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_mod_wide_wide()
         {
             float2x3 a0 = float2x3(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f);
@@ -770,7 +770,7 @@ public static void float2x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_mod_wide_scalar()
         {
             float2x3 a0 = float2x3(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f);
@@ -794,7 +794,7 @@ public static void float2x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -818,7 +818,7 @@ public static void float2x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_plus()
         {
             float2x3 a0 = float2x3(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f);
@@ -838,7 +838,7 @@ public static void float2x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_neg()
         {
             float2x3 a0 = float2x3(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f);
@@ -858,7 +858,7 @@ public static void float2x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_prefix_inc()
         {
             float2x3 a0 = float2x3(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f);
@@ -878,7 +878,7 @@ public static void float2x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_postfix_inc()
         {
             float2x3 a0 = float2x3(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f);
@@ -898,7 +898,7 @@ public static void float2x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_prefix_dec()
         {
             float2x3 a0 = float2x3(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f);
@@ -918,7 +918,7 @@ public static void float2x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x3_operator_postfix_dec()
         {
             float2x3 a0 = float2x3(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f);
@@ -938,7 +938,7 @@ public static void float2x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void float2x3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new float2x3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestFloat2x4.gen.cs b/src/Tests/Tests/Shared/TestFloat2x4.gen.cs
index d959a802..19447921 100644
--- a/src/Tests/Tests/Shared/TestFloat2x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat2x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat2x4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_zero()
         {
             TestUtils.AreEqual(0.0f, float2x4.zero.c0.x);
@@ -28,7 +28,7 @@ public static void float2x4_zero()
             TestUtils.AreEqual(0.0f, float2x4.zero.c3.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_equal_wide_wide()
         {
             float2x4 a0 = float2x4(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f);
@@ -52,7 +52,7 @@ public static void float2x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_equal_wide_scalar()
         {
             float2x4 a0 = float2x4(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f);
@@ -76,7 +76,7 @@ public static void float2x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -100,7 +100,7 @@ public static void float2x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_not_equal_wide_wide()
         {
             float2x4 a0 = float2x4(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f);
@@ -124,7 +124,7 @@ public static void float2x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_not_equal_wide_scalar()
         {
             float2x4 a0 = float2x4(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f);
@@ -148,7 +148,7 @@ public static void float2x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -172,7 +172,7 @@ public static void float2x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_less_wide_wide()
         {
             float2x4 a0 = float2x4(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f);
@@ -196,7 +196,7 @@ public static void float2x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_less_wide_scalar()
         {
             float2x4 a0 = float2x4(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f);
@@ -220,7 +220,7 @@ public static void float2x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -244,7 +244,7 @@ public static void float2x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_greater_wide_wide()
         {
             float2x4 a0 = float2x4(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f);
@@ -268,7 +268,7 @@ public static void float2x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_greater_wide_scalar()
         {
             float2x4 a0 = float2x4(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f);
@@ -292,7 +292,7 @@ public static void float2x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -316,7 +316,7 @@ public static void float2x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_less_equal_wide_wide()
         {
             float2x4 a0 = float2x4(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f);
@@ -340,7 +340,7 @@ public static void float2x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_less_equal_wide_scalar()
         {
             float2x4 a0 = float2x4(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f);
@@ -364,7 +364,7 @@ public static void float2x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -388,7 +388,7 @@ public static void float2x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_greater_equal_wide_wide()
         {
             float2x4 a0 = float2x4(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f);
@@ -412,7 +412,7 @@ public static void float2x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_greater_equal_wide_scalar()
         {
             float2x4 a0 = float2x4(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f);
@@ -436,7 +436,7 @@ public static void float2x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -460,7 +460,7 @@ public static void float2x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_add_wide_wide()
         {
             float2x4 a0 = float2x4(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f);
@@ -484,7 +484,7 @@ public static void float2x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_add_wide_scalar()
         {
             float2x4 a0 = float2x4(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f);
@@ -508,7 +508,7 @@ public static void float2x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -532,7 +532,7 @@ public static void float2x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_sub_wide_wide()
         {
             float2x4 a0 = float2x4(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f);
@@ -556,7 +556,7 @@ public static void float2x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_sub_wide_scalar()
         {
             float2x4 a0 = float2x4(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f);
@@ -580,7 +580,7 @@ public static void float2x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -604,7 +604,7 @@ public static void float2x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_mul_wide_wide()
         {
             float2x4 a0 = float2x4(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f);
@@ -628,7 +628,7 @@ public static void float2x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_mul_wide_scalar()
         {
             float2x4 a0 = float2x4(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f);
@@ -652,7 +652,7 @@ public static void float2x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -676,7 +676,7 @@ public static void float2x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_div_wide_wide()
         {
             float2x4 a0 = float2x4(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f);
@@ -700,7 +700,7 @@ public static void float2x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_div_wide_scalar()
         {
             float2x4 a0 = float2x4(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f);
@@ -724,7 +724,7 @@ public static void float2x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -748,7 +748,7 @@ public static void float2x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_mod_wide_wide()
         {
             float2x4 a0 = float2x4(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f);
@@ -772,7 +772,7 @@ public static void float2x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_mod_wide_scalar()
         {
             float2x4 a0 = float2x4(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f);
@@ -796,7 +796,7 @@ public static void float2x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -820,7 +820,7 @@ public static void float2x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_plus()
         {
             float2x4 a0 = float2x4(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f);
@@ -840,7 +840,7 @@ public static void float2x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_neg()
         {
             float2x4 a0 = float2x4(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f);
@@ -860,7 +860,7 @@ public static void float2x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_prefix_inc()
         {
             float2x4 a0 = float2x4(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f);
@@ -880,7 +880,7 @@ public static void float2x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_postfix_inc()
         {
             float2x4 a0 = float2x4(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f);
@@ -900,7 +900,7 @@ public static void float2x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_prefix_dec()
         {
             float2x4 a0 = float2x4(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f);
@@ -920,7 +920,7 @@ public static void float2x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x4_operator_postfix_dec()
         {
             float2x4 a0 = float2x4(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f);
@@ -940,7 +940,7 @@ public static void float2x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void float2x4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new float2x4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestFloat3.gen.cs b/src/Tests/Tests/Shared/TestFloat3.gen.cs
index 48c5b1a4..40a4db85 100644
--- a/src/Tests/Tests/Shared/TestFloat3.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_zero()
         {
             TestUtils.AreEqual(0.0f, float3.zero.x);
@@ -23,7 +23,7 @@ public static void float3_zero()
             TestUtils.AreEqual(0.0f, float3.zero.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_constructor()
         {
             float3 a = new float3(1, 2, 3);
@@ -32,7 +32,7 @@ public static void float3_constructor()
             TestUtils.AreEqual(3, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_scalar_constructor()
         {
             float3 a = new float3(17.0f);
@@ -41,7 +41,7 @@ public static void float3_scalar_constructor()
             TestUtils.AreEqual(17.0f, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_static_constructor()
         {
             float3 a = float3(1, 2, 3);
@@ -50,7 +50,7 @@ public static void float3_static_constructor()
             TestUtils.AreEqual(3, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_static_scalar_constructor()
         {
             float3 a = float3(17.0f);
@@ -59,7 +59,7 @@ public static void float3_static_scalar_constructor()
             TestUtils.AreEqual(17.0f, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_equal_wide_wide()
         {
             float3 a0 = float3(492.1576f, -495.206329f, 227.457642f);
@@ -83,7 +83,7 @@ public static void float3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_equal_wide_scalar()
         {
             float3 a0 = float3(-303.230072f, 451.5263f, -253.655884f);
@@ -107,7 +107,7 @@ public static void float3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -131,7 +131,7 @@ public static void float3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_not_equal_wide_wide()
         {
             float3 a0 = float3(430.842529f, 104.69f, 225.802429f);
@@ -155,7 +155,7 @@ public static void float3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_not_equal_wide_scalar()
         {
             float3 a0 = float3(-16.9145813f, 168.8341f, -462.713531f);
@@ -179,7 +179,7 @@ public static void float3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -203,7 +203,7 @@ public static void float3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_less_wide_wide()
         {
             float3 a0 = float3(196.84259f, 336.4098f, 251.963745f);
@@ -227,7 +227,7 @@ public static void float3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_less_wide_scalar()
         {
             float3 a0 = float3(-132.057312f, -192.465f, -66.8345947f);
@@ -251,7 +251,7 @@ public static void float3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -275,7 +275,7 @@ public static void float3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_greater_wide_wide()
         {
             float3 a0 = float3(483.5014f, 310.8156f, 106.966187f);
@@ -299,7 +299,7 @@ public static void float3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_greater_wide_scalar()
         {
             float3 a0 = float3(64.31793f, -397.703461f, 431.8769f);
@@ -323,7 +323,7 @@ public static void float3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -347,7 +347,7 @@ public static void float3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_less_equal_wide_wide()
         {
             float3 a0 = float3(-438.523132f, 210.489441f, 4.87731934f);
@@ -371,7 +371,7 @@ public static void float3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_less_equal_wide_scalar()
         {
             float3 a0 = float3(193.49585f, 168.915527f, -313.993073f);
@@ -395,7 +395,7 @@ public static void float3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -419,7 +419,7 @@ public static void float3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_greater_equal_wide_wide()
         {
             float3 a0 = float3(-507.9286f, 504.4975f, -385.4345f);
@@ -443,7 +443,7 @@ public static void float3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_greater_equal_wide_scalar()
         {
             float3 a0 = float3(465.152161f, -424.886078f, -209.2211f);
@@ -467,7 +467,7 @@ public static void float3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -491,7 +491,7 @@ public static void float3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_add_wide_wide()
         {
             float3 a0 = float3(506.129028f, -501.779816f, 420.084778f);
@@ -515,7 +515,7 @@ public static void float3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_add_wide_scalar()
         {
             float3 a0 = float3(-194.514191f, 338.5484f, 246.971375f);
@@ -539,7 +539,7 @@ public static void float3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -563,7 +563,7 @@ public static void float3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_sub_wide_wide()
         {
             float3 a0 = float3(160.492249f, 11.223938f, 359.200134f);
@@ -587,7 +587,7 @@ public static void float3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_sub_wide_scalar()
         {
             float3 a0 = float3(207.389587f, 248.457764f, -384.8239f);
@@ -611,7 +611,7 @@ public static void float3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -635,7 +635,7 @@ public static void float3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_mul_wide_wide()
         {
             float3 a0 = float3(-482.7138f, -407.2935f, 137.700562f);
@@ -659,7 +659,7 @@ public static void float3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_mul_wide_scalar()
         {
             float3 a0 = float3(-96.31882f, -277.142273f, -239.93689f);
@@ -683,7 +683,7 @@ public static void float3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -707,7 +707,7 @@ public static void float3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_div_wide_wide()
         {
             float3 a0 = float3(-353.131439f, -102.799866f, 51.3191528f);
@@ -731,7 +731,7 @@ public static void float3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_div_wide_scalar()
         {
             float3 a0 = float3(171.3424f, 0.103393555f, 57.8882446f);
@@ -755,7 +755,7 @@ public static void float3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -779,7 +779,7 @@ public static void float3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_mod_wide_wide()
         {
             float3 a0 = float3(-388.8125f, 181.681213f, -167.078735f);
@@ -803,7 +803,7 @@ public static void float3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_mod_wide_scalar()
         {
             float3 a0 = float3(-244.499634f, -211.8193f, -145.926788f);
@@ -827,7 +827,7 @@ public static void float3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -851,7 +851,7 @@ public static void float3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_plus()
         {
             float3 a0 = float3(-418.829559f, -405.79895f, -34.04178f);
@@ -871,7 +871,7 @@ public static void float3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_neg()
         {
             float3 a0 = float3(148.461731f, -467.122681f, 132.04718f);
@@ -891,7 +891,7 @@ public static void float3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_prefix_inc()
         {
             float3 a0 = float3(-139.842072f, -56.7436523f, -381.955322f);
@@ -911,7 +911,7 @@ public static void float3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_postfix_inc()
         {
             float3 a0 = float3(-396.669739f, 511.20752f, 249.111267f);
@@ -931,7 +931,7 @@ public static void float3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_prefix_dec()
         {
             float3 a0 = float3(123.128723f, 256.84375f, 156.330811f);
@@ -951,7 +951,7 @@ public static void float3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_operator_postfix_dec()
         {
             float3 a0 = float3(379.6883f, 302.692871f, -176.07135f);
@@ -971,7 +971,7 @@ public static void float3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_shuffle_result_1()
         {
             float3 a = float3(0, 1, 2);
@@ -985,7 +985,7 @@ public static void float3_shuffle_result_1()
             TestUtils.AreEqual((5), shuffle(a, b, ShuffleComponent.RightZ));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_shuffle_result_2()
         {
             float3 a = float3(0, 1, 2);
@@ -1009,7 +1009,7 @@ public static void float3_shuffle_result_2()
             TestUtils.AreEqual(float2(1, 2), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_shuffle_result_3()
         {
             float3 a = float3(0, 1, 2);
@@ -1033,7 +1033,7 @@ public static void float3_shuffle_result_3()
             TestUtils.AreEqual(float3(4, 0, 5), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_shuffle_result_4()
         {
             float3 a = float3(0, 1, 2);
@@ -1057,7 +1057,7 @@ public static void float3_shuffle_result_4()
             TestUtils.AreEqual(float4(2, 5, 0, 4), shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightY));
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void float3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new float3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestFloat3x2.gen.cs b/src/Tests/Tests/Shared/TestFloat3x2.gen.cs
index a497e7be..dabe0e58 100644
--- a/src/Tests/Tests/Shared/TestFloat3x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat3x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat3x2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_zero()
         {
             TestUtils.AreEqual(0.0f, float3x2.zero.c0.x);
@@ -26,7 +26,7 @@ public static void float3x2_zero()
             TestUtils.AreEqual(0.0f, float3x2.zero.c1.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_equal_wide_wide()
         {
             float3x2 a0 = float3x2(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f);
@@ -50,7 +50,7 @@ public static void float3x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_equal_wide_scalar()
         {
             float3x2 a0 = float3x2(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f);
@@ -74,7 +74,7 @@ public static void float3x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -98,7 +98,7 @@ public static void float3x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_not_equal_wide_wide()
         {
             float3x2 a0 = float3x2(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f);
@@ -122,7 +122,7 @@ public static void float3x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_not_equal_wide_scalar()
         {
             float3x2 a0 = float3x2(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f);
@@ -146,7 +146,7 @@ public static void float3x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -170,7 +170,7 @@ public static void float3x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_less_wide_wide()
         {
             float3x2 a0 = float3x2(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f);
@@ -194,7 +194,7 @@ public static void float3x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_less_wide_scalar()
         {
             float3x2 a0 = float3x2(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f);
@@ -218,7 +218,7 @@ public static void float3x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -242,7 +242,7 @@ public static void float3x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_greater_wide_wide()
         {
             float3x2 a0 = float3x2(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f);
@@ -266,7 +266,7 @@ public static void float3x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_greater_wide_scalar()
         {
             float3x2 a0 = float3x2(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f);
@@ -290,7 +290,7 @@ public static void float3x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -314,7 +314,7 @@ public static void float3x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_less_equal_wide_wide()
         {
             float3x2 a0 = float3x2(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f);
@@ -338,7 +338,7 @@ public static void float3x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_less_equal_wide_scalar()
         {
             float3x2 a0 = float3x2(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f);
@@ -362,7 +362,7 @@ public static void float3x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -386,7 +386,7 @@ public static void float3x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_greater_equal_wide_wide()
         {
             float3x2 a0 = float3x2(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f);
@@ -410,7 +410,7 @@ public static void float3x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_greater_equal_wide_scalar()
         {
             float3x2 a0 = float3x2(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f);
@@ -434,7 +434,7 @@ public static void float3x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -458,7 +458,7 @@ public static void float3x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_add_wide_wide()
         {
             float3x2 a0 = float3x2(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f);
@@ -482,7 +482,7 @@ public static void float3x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_add_wide_scalar()
         {
             float3x2 a0 = float3x2(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f);
@@ -506,7 +506,7 @@ public static void float3x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -530,7 +530,7 @@ public static void float3x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_sub_wide_wide()
         {
             float3x2 a0 = float3x2(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f);
@@ -554,7 +554,7 @@ public static void float3x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_sub_wide_scalar()
         {
             float3x2 a0 = float3x2(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f);
@@ -578,7 +578,7 @@ public static void float3x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -602,7 +602,7 @@ public static void float3x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_mul_wide_wide()
         {
             float3x2 a0 = float3x2(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f);
@@ -626,7 +626,7 @@ public static void float3x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_mul_wide_scalar()
         {
             float3x2 a0 = float3x2(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f);
@@ -650,7 +650,7 @@ public static void float3x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -674,7 +674,7 @@ public static void float3x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_div_wide_wide()
         {
             float3x2 a0 = float3x2(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f);
@@ -698,7 +698,7 @@ public static void float3x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_div_wide_scalar()
         {
             float3x2 a0 = float3x2(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f);
@@ -722,7 +722,7 @@ public static void float3x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -746,7 +746,7 @@ public static void float3x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_mod_wide_wide()
         {
             float3x2 a0 = float3x2(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f);
@@ -770,7 +770,7 @@ public static void float3x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_mod_wide_scalar()
         {
             float3x2 a0 = float3x2(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f);
@@ -794,7 +794,7 @@ public static void float3x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -818,7 +818,7 @@ public static void float3x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_plus()
         {
             float3x2 a0 = float3x2(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f);
@@ -838,7 +838,7 @@ public static void float3x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_neg()
         {
             float3x2 a0 = float3x2(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f);
@@ -858,7 +858,7 @@ public static void float3x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_prefix_inc()
         {
             float3x2 a0 = float3x2(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f);
@@ -878,7 +878,7 @@ public static void float3x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_postfix_inc()
         {
             float3x2 a0 = float3x2(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f);
@@ -898,7 +898,7 @@ public static void float3x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_prefix_dec()
         {
             float3x2 a0 = float3x2(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f);
@@ -918,7 +918,7 @@ public static void float3x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x2_operator_postfix_dec()
         {
             float3x2 a0 = float3x2(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f);
@@ -938,7 +938,7 @@ public static void float3x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void float3x2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new float3x2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestFloat3x3.gen.cs b/src/Tests/Tests/Shared/TestFloat3x3.gen.cs
index 37e72288..6326f34f 100644
--- a/src/Tests/Tests/Shared/TestFloat3x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat3x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat3x3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_zero()
         {
             TestUtils.AreEqual(0.0f, float3x3.zero.c0.x);
@@ -29,7 +29,7 @@ public static void float3x3_zero()
             TestUtils.AreEqual(0.0f, float3x3.zero.c2.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_identity()
         {
             TestUtils.AreEqual(1.0f, float3x3.identity.c0.x);
@@ -43,7 +43,7 @@ public static void float3x3_identity()
             TestUtils.AreEqual(1.0f, float3x3.identity.c2.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_equal_wide_wide()
         {
             float3x3 a0 = float3x3(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f, 163.232117f);
@@ -67,7 +67,7 @@ public static void float3x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_equal_wide_scalar()
         {
             float3x3 a0 = float3x3(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f, -57.4773865f);
@@ -91,7 +91,7 @@ public static void float3x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -115,7 +115,7 @@ public static void float3x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_not_equal_wide_wide()
         {
             float3x3 a0 = float3x3(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f, -203.301971f);
@@ -139,7 +139,7 @@ public static void float3x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_not_equal_wide_scalar()
         {
             float3x3 a0 = float3x3(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f, -386.611176f);
@@ -163,7 +163,7 @@ public static void float3x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -187,7 +187,7 @@ public static void float3x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_less_wide_wide()
         {
             float3x3 a0 = float3x3(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f, 164.678833f);
@@ -211,7 +211,7 @@ public static void float3x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_less_wide_scalar()
         {
             float3x3 a0 = float3x3(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f, -20.4526062f);
@@ -235,7 +235,7 @@ public static void float3x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -259,7 +259,7 @@ public static void float3x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_greater_wide_wide()
         {
             float3x3 a0 = float3x3(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f, -24.74054f);
@@ -283,7 +283,7 @@ public static void float3x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_greater_wide_scalar()
         {
             float3x3 a0 = float3x3(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f, -405.7846f);
@@ -307,7 +307,7 @@ public static void float3x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -331,7 +331,7 @@ public static void float3x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_less_equal_wide_wide()
         {
             float3x3 a0 = float3x3(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f, 458.530273f);
@@ -355,7 +355,7 @@ public static void float3x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_less_equal_wide_scalar()
         {
             float3x3 a0 = float3x3(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f, -1.35775757f);
@@ -379,7 +379,7 @@ public static void float3x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -403,7 +403,7 @@ public static void float3x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_greater_equal_wide_wide()
         {
             float3x3 a0 = float3x3(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f, 456.9688f);
@@ -427,7 +427,7 @@ public static void float3x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_greater_equal_wide_scalar()
         {
             float3x3 a0 = float3x3(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f, 393.278076f);
@@ -451,7 +451,7 @@ public static void float3x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -475,7 +475,7 @@ public static void float3x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_add_wide_wide()
         {
             float3x3 a0 = float3x3(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f, 462.4137f);
@@ -499,7 +499,7 @@ public static void float3x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_add_wide_scalar()
         {
             float3x3 a0 = float3x3(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f, -242.118744f);
@@ -523,7 +523,7 @@ public static void float3x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -547,7 +547,7 @@ public static void float3x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_sub_wide_wide()
         {
             float3x3 a0 = float3x3(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f, 317.706848f);
@@ -571,7 +571,7 @@ public static void float3x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_sub_wide_scalar()
         {
             float3x3 a0 = float3x3(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f, 480.857971f);
@@ -595,7 +595,7 @@ public static void float3x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -619,7 +619,7 @@ public static void float3x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_mul_wide_wide()
         {
             float3x3 a0 = float3x3(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f, 45.8687744f);
@@ -643,7 +643,7 @@ public static void float3x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_mul_wide_scalar()
         {
             float3x3 a0 = float3x3(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f, -338.29248f);
@@ -667,7 +667,7 @@ public static void float3x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -691,7 +691,7 @@ public static void float3x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_div_wide_wide()
         {
             float3x3 a0 = float3x3(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f, -237.69455f);
@@ -715,7 +715,7 @@ public static void float3x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_div_wide_scalar()
         {
             float3x3 a0 = float3x3(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f, 146.466858f);
@@ -739,7 +739,7 @@ public static void float3x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -763,7 +763,7 @@ public static void float3x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_mod_wide_wide()
         {
             float3x3 a0 = float3x3(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f, 335.271f);
@@ -787,7 +787,7 @@ public static void float3x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_mod_wide_scalar()
         {
             float3x3 a0 = float3x3(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f, 335.166138f);
@@ -811,7 +811,7 @@ public static void float3x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -835,7 +835,7 @@ public static void float3x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_plus()
         {
             float3x3 a0 = float3x3(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f, -386.059845f);
@@ -855,7 +855,7 @@ public static void float3x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_neg()
         {
             float3x3 a0 = float3x3(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f, -299.093384f);
@@ -875,7 +875,7 @@ public static void float3x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_prefix_inc()
         {
             float3x3 a0 = float3x3(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f, 362.212769f);
@@ -895,7 +895,7 @@ public static void float3x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_postfix_inc()
         {
             float3x3 a0 = float3x3(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f, 167.852112f);
@@ -915,7 +915,7 @@ public static void float3x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_prefix_dec()
         {
             float3x3 a0 = float3x3(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f, 125.109619f);
@@ -935,7 +935,7 @@ public static void float3x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_operator_postfix_dec()
         {
             float3x3 a0 = float3x3(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f, -27.8892212f);
@@ -955,7 +955,7 @@ public static void float3x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void float3x3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new float3x3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestFloat3x4.gen.cs b/src/Tests/Tests/Shared/TestFloat3x4.gen.cs
index 57e75392..78522532 100644
--- a/src/Tests/Tests/Shared/TestFloat3x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat3x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat3x4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_zero()
         {
             TestUtils.AreEqual(0.0f, float3x4.zero.c0.x);
@@ -32,7 +32,7 @@ public static void float3x4_zero()
             TestUtils.AreEqual(0.0f, float3x4.zero.c3.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_equal_wide_wide()
         {
             float3x4 a0 = float3x4(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f, 163.232117f, -165.271f, 470.8777f, -423.942566f);
@@ -56,7 +56,7 @@ public static void float3x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_equal_wide_scalar()
         {
             float3x4 a0 = float3x4(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f, -57.4773865f, -182.049744f, 406.513733f, 370.886f);
@@ -80,7 +80,7 @@ public static void float3x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -104,7 +104,7 @@ public static void float3x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_not_equal_wide_wide()
         {
             float3x4 a0 = float3x4(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f, -203.301971f, -505.763245f, 162.17218f, 1.156189f);
@@ -128,7 +128,7 @@ public static void float3x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_not_equal_wide_scalar()
         {
             float3x4 a0 = float3x4(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f, -386.611176f, -281.021f, -270.26886f, -403.9637f);
@@ -152,7 +152,7 @@ public static void float3x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -176,7 +176,7 @@ public static void float3x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_less_wide_wide()
         {
             float3x4 a0 = float3x4(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f, 164.678833f, -350.9449f, 3.84143066f, 125.409729f);
@@ -200,7 +200,7 @@ public static void float3x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_less_wide_scalar()
         {
             float3x4 a0 = float3x4(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f, -20.4526062f, 225.2915f, 307.4842f, 274.015259f);
@@ -224,7 +224,7 @@ public static void float3x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -248,7 +248,7 @@ public static void float3x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_greater_wide_wide()
         {
             float3x4 a0 = float3x4(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f, -24.74054f, 319.782654f, -120.158569f, -289.008575f);
@@ -272,7 +272,7 @@ public static void float3x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_greater_wide_scalar()
         {
             float3x4 a0 = float3x4(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f, -405.7846f, 171.565369f, -241.807281f, 333.5782f);
@@ -296,7 +296,7 @@ public static void float3x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -320,7 +320,7 @@ public static void float3x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_less_equal_wide_wide()
         {
             float3x4 a0 = float3x4(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f, 458.530273f, -294.064758f, 23.62262f, -34.2840576f);
@@ -344,7 +344,7 @@ public static void float3x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_less_equal_wide_scalar()
         {
             float3x4 a0 = float3x4(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f, -1.35775757f, -268.899475f, 398.991943f, -471.253082f);
@@ -368,7 +368,7 @@ public static void float3x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -392,7 +392,7 @@ public static void float3x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_greater_equal_wide_wide()
         {
             float3x4 a0 = float3x4(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f, 456.9688f, -211.010162f, 182.411377f, -53.59604f);
@@ -416,7 +416,7 @@ public static void float3x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_greater_equal_wide_scalar()
         {
             float3x4 a0 = float3x4(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f, 393.278076f, -315.701538f, 441.011536f, -509.781555f);
@@ -440,7 +440,7 @@ public static void float3x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -464,7 +464,7 @@ public static void float3x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_add_wide_wide()
         {
             float3x4 a0 = float3x4(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f, 462.4137f, -46.17871f, 401.170044f, -454.124146f);
@@ -488,7 +488,7 @@ public static void float3x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_add_wide_scalar()
         {
             float3x4 a0 = float3x4(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f, -242.118744f, 82.50134f, 6.79937744f, -484.6998f);
@@ -512,7 +512,7 @@ public static void float3x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -536,7 +536,7 @@ public static void float3x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_sub_wide_wide()
         {
             float3x4 a0 = float3x4(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f, 317.706848f, 447.060425f, -489.074158f, -230.008392f);
@@ -560,7 +560,7 @@ public static void float3x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_sub_wide_scalar()
         {
             float3x4 a0 = float3x4(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f, 480.857971f, 16.3381958f, -366.865448f, -35.5231f);
@@ -584,7 +584,7 @@ public static void float3x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -608,7 +608,7 @@ public static void float3x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_mul_wide_wide()
         {
             float3x4 a0 = float3x4(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f, 45.8687744f, 363.3261f, -328.118958f, -471.023071f);
@@ -632,7 +632,7 @@ public static void float3x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_mul_wide_scalar()
         {
             float3x4 a0 = float3x4(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f, -338.29248f, 53.7962646f, 243.757324f, 135.354675f);
@@ -656,7 +656,7 @@ public static void float3x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -680,7 +680,7 @@ public static void float3x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_div_wide_wide()
         {
             float3x4 a0 = float3x4(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f, -237.69455f, -432.546875f, 200.2655f, 361.4416f);
@@ -704,7 +704,7 @@ public static void float3x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_div_wide_scalar()
         {
             float3x4 a0 = float3x4(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f, 146.466858f, -499.843567f, 58.68634f, -453.2058f);
@@ -728,7 +728,7 @@ public static void float3x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -752,7 +752,7 @@ public static void float3x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_mod_wide_wide()
         {
             float3x4 a0 = float3x4(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f, 335.271f, -503.608521f, 191.022522f, 289.742676f);
@@ -776,7 +776,7 @@ public static void float3x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_mod_wide_scalar()
         {
             float3x4 a0 = float3x4(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f, 335.166138f, 101.706482f, 319.4715f, -285.4023f);
@@ -800,7 +800,7 @@ public static void float3x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -824,7 +824,7 @@ public static void float3x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_plus()
         {
             float3x4 a0 = float3x4(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f, -386.059845f, 4.95440674f, -418.645264f, 504.474854f);
@@ -844,7 +844,7 @@ public static void float3x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_neg()
         {
             float3x4 a0 = float3x4(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f, -299.093384f, -383.014069f, 407.709778f, 168.735474f);
@@ -864,7 +864,7 @@ public static void float3x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_prefix_inc()
         {
             float3x4 a0 = float3x4(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f, 362.212769f, 401.6148f, 130.90918f, -450.230164f);
@@ -884,7 +884,7 @@ public static void float3x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_postfix_inc()
         {
             float3x4 a0 = float3x4(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f, 167.852112f, 147.94397f, -326.1076f, 41.03357f);
@@ -904,7 +904,7 @@ public static void float3x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_prefix_dec()
         {
             float3x4 a0 = float3x4(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f, 125.109619f, 469.844727f, 45.5366821f, 376.046875f);
@@ -924,7 +924,7 @@ public static void float3x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_operator_postfix_dec()
         {
             float3x4 a0 = float3x4(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f, -27.8892212f, -100.761841f, 156.14032f, 479.9452f);
@@ -944,7 +944,7 @@ public static void float3x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void float3x4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new float3x4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestFloat4.gen.cs b/src/Tests/Tests/Shared/TestFloat4.gen.cs
index eec3bd88..9ac6757c 100644
--- a/src/Tests/Tests/Shared/TestFloat4.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_zero()
         {
             TestUtils.AreEqual(0.0f, float4.zero.x);
@@ -24,7 +24,7 @@ public static void float4_zero()
             TestUtils.AreEqual(0.0f, float4.zero.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_constructor()
         {
             float4 a = new float4(1, 2, 3, 4);
@@ -34,7 +34,7 @@ public static void float4_constructor()
             TestUtils.AreEqual(4, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_scalar_constructor()
         {
             float4 a = new float4(17.0f);
@@ -44,7 +44,7 @@ public static void float4_scalar_constructor()
             TestUtils.AreEqual(17.0f, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_static_constructor()
         {
             float4 a = float4(1, 2, 3, 4);
@@ -54,7 +54,7 @@ public static void float4_static_constructor()
             TestUtils.AreEqual(4, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_static_scalar_constructor()
         {
             float4 a = float4(17.0f);
@@ -64,7 +64,7 @@ public static void float4_static_scalar_constructor()
             TestUtils.AreEqual(17.0f, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_equal_wide_wide()
         {
             float4 a0 = float4(492.1576f, -495.206329f, 227.457642f, -147.374054f);
@@ -88,7 +88,7 @@ public static void float4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_equal_wide_scalar()
         {
             float4 a0 = float4(-303.230072f, 451.5263f, -253.655884f, -105.203644f);
@@ -112,7 +112,7 @@ public static void float4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -136,7 +136,7 @@ public static void float4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_not_equal_wide_wide()
         {
             float4 a0 = float4(430.842529f, 104.69f, 225.802429f, -310.5702f);
@@ -160,7 +160,7 @@ public static void float4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_not_equal_wide_scalar()
         {
             float4 a0 = float4(-16.9145813f, 168.8341f, -462.713531f, 130.307739f);
@@ -184,7 +184,7 @@ public static void float4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -208,7 +208,7 @@ public static void float4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_less_wide_wide()
         {
             float4 a0 = float4(196.84259f, 336.4098f, 251.963745f, 257.655945f);
@@ -232,7 +232,7 @@ public static void float4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_less_wide_scalar()
         {
             float4 a0 = float4(-132.057312f, -192.465f, -66.8345947f, -379.017517f);
@@ -256,7 +256,7 @@ public static void float4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -280,7 +280,7 @@ public static void float4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_greater_wide_wide()
         {
             float4 a0 = float4(483.5014f, 310.8156f, 106.966187f, 295.7353f);
@@ -304,7 +304,7 @@ public static void float4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_greater_wide_scalar()
         {
             float4 a0 = float4(64.31793f, -397.703461f, 431.8769f, 85.703f);
@@ -328,7 +328,7 @@ public static void float4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -352,7 +352,7 @@ public static void float4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_less_equal_wide_wide()
         {
             float4 a0 = float4(-438.523132f, 210.489441f, 4.87731934f, -137.297943f);
@@ -376,7 +376,7 @@ public static void float4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_less_equal_wide_scalar()
         {
             float4 a0 = float4(193.49585f, 168.915527f, -313.993073f, 81.8269653f);
@@ -400,7 +400,7 @@ public static void float4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -424,7 +424,7 @@ public static void float4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_greater_equal_wide_wide()
         {
             float4 a0 = float4(-507.9286f, 504.4975f, -385.4345f, -262.323425f);
@@ -448,7 +448,7 @@ public static void float4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_greater_equal_wide_scalar()
         {
             float4 a0 = float4(465.152161f, -424.886078f, -209.2211f, 58.7798462f);
@@ -472,7 +472,7 @@ public static void float4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -496,7 +496,7 @@ public static void float4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_add_wide_wide()
         {
             float4 a0 = float4(506.129028f, -501.779816f, 420.084778f, -186.032074f);
@@ -520,7 +520,7 @@ public static void float4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_add_wide_scalar()
         {
             float4 a0 = float4(-194.514191f, 338.5484f, 246.971375f, 100.510925f);
@@ -544,7 +544,7 @@ public static void float4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -568,7 +568,7 @@ public static void float4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_sub_wide_wide()
         {
             float4 a0 = float4(160.492249f, 11.223938f, 359.200134f, -498.2283f);
@@ -592,7 +592,7 @@ public static void float4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_sub_wide_scalar()
         {
             float4 a0 = float4(207.389587f, 248.457764f, -384.8239f, -205.344757f);
@@ -616,7 +616,7 @@ public static void float4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -640,7 +640,7 @@ public static void float4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_mul_wide_wide()
         {
             float4 a0 = float4(-482.7138f, -407.2935f, 137.700562f, 208.541138f);
@@ -664,7 +664,7 @@ public static void float4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_mul_wide_scalar()
         {
             float4 a0 = float4(-96.31882f, -277.142273f, -239.93689f, 509.531433f);
@@ -688,7 +688,7 @@ public static void float4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -712,7 +712,7 @@ public static void float4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_div_wide_wide()
         {
             float4 a0 = float4(-353.131439f, -102.799866f, 51.3191528f, -191.871674f);
@@ -736,7 +736,7 @@ public static void float4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_div_wide_scalar()
         {
             float4 a0 = float4(171.3424f, 0.103393555f, 57.8882446f, -256.130737f);
@@ -760,7 +760,7 @@ public static void float4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -784,7 +784,7 @@ public static void float4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_mod_wide_wide()
         {
             float4 a0 = float4(-388.8125f, 181.681213f, -167.078735f, 432.820129f);
@@ -808,7 +808,7 @@ public static void float4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_mod_wide_scalar()
         {
             float4 a0 = float4(-244.499634f, -211.8193f, -145.926788f, -304.9182f);
@@ -832,7 +832,7 @@ public static void float4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -856,7 +856,7 @@ public static void float4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_plus()
         {
             float4 a0 = float4(-418.829559f, -405.79895f, -34.04178f, 236.999268f);
@@ -876,7 +876,7 @@ public static void float4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_neg()
         {
             float4 a0 = float4(148.461731f, -467.122681f, 132.04718f, 183.522644f);
@@ -896,7 +896,7 @@ public static void float4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_prefix_inc()
         {
             float4 a0 = float4(-139.842072f, -56.7436523f, -381.955322f, 509.796326f);
@@ -916,7 +916,7 @@ public static void float4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_postfix_inc()
         {
             float4 a0 = float4(-396.669739f, 511.20752f, 249.111267f, -128.817322f);
@@ -936,7 +936,7 @@ public static void float4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_prefix_dec()
         {
             float4 a0 = float4(123.128723f, 256.84375f, 156.330811f, 461.737427f);
@@ -956,7 +956,7 @@ public static void float4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_operator_postfix_dec()
         {
             float4 a0 = float4(379.6883f, 302.692871f, -176.07135f, -291.2527f);
@@ -976,7 +976,7 @@ public static void float4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_shuffle_result_1()
         {
             float4 a = float4(0, 1, 2, 3);
@@ -992,7 +992,7 @@ public static void float4_shuffle_result_1()
             TestUtils.AreEqual((7), shuffle(a, b, ShuffleComponent.RightW));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_shuffle_result_2()
         {
             float4 a = float4(0, 1, 2, 3);
@@ -1016,7 +1016,7 @@ public static void float4_shuffle_result_2()
             TestUtils.AreEqual(float2(1, 3), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_shuffle_result_3()
         {
             float4 a = float4(0, 1, 2, 3);
@@ -1040,7 +1040,7 @@ public static void float4_shuffle_result_3()
             TestUtils.AreEqual(float3(5, 1, 7), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_shuffle_result_4()
         {
             float4 a = float4(0, 1, 2, 3);
@@ -1064,7 +1064,7 @@ public static void float4_shuffle_result_4()
             TestUtils.AreEqual(float4(3, 7, 1, 5), shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.LeftY, ShuffleComponent.RightY));
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void float4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new float4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestFloat4x2.gen.cs b/src/Tests/Tests/Shared/TestFloat4x2.gen.cs
index ef36f471..492a62f9 100644
--- a/src/Tests/Tests/Shared/TestFloat4x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat4x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat4x2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_zero()
         {
             TestUtils.AreEqual(0.0f, float4x2.zero.c0.x);
@@ -28,7 +28,7 @@ public static void float4x2_zero()
             TestUtils.AreEqual(0.0f, float4x2.zero.c1.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_equal_wide_wide()
         {
             float4x2 a0 = float4x2(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f);
@@ -52,7 +52,7 @@ public static void float4x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_equal_wide_scalar()
         {
             float4x2 a0 = float4x2(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f);
@@ -76,7 +76,7 @@ public static void float4x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -100,7 +100,7 @@ public static void float4x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_not_equal_wide_wide()
         {
             float4x2 a0 = float4x2(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f);
@@ -124,7 +124,7 @@ public static void float4x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_not_equal_wide_scalar()
         {
             float4x2 a0 = float4x2(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f);
@@ -148,7 +148,7 @@ public static void float4x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -172,7 +172,7 @@ public static void float4x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_less_wide_wide()
         {
             float4x2 a0 = float4x2(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f);
@@ -196,7 +196,7 @@ public static void float4x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_less_wide_scalar()
         {
             float4x2 a0 = float4x2(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f);
@@ -220,7 +220,7 @@ public static void float4x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -244,7 +244,7 @@ public static void float4x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_greater_wide_wide()
         {
             float4x2 a0 = float4x2(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f);
@@ -268,7 +268,7 @@ public static void float4x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_greater_wide_scalar()
         {
             float4x2 a0 = float4x2(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f);
@@ -292,7 +292,7 @@ public static void float4x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -316,7 +316,7 @@ public static void float4x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_less_equal_wide_wide()
         {
             float4x2 a0 = float4x2(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f);
@@ -340,7 +340,7 @@ public static void float4x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_less_equal_wide_scalar()
         {
             float4x2 a0 = float4x2(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f);
@@ -364,7 +364,7 @@ public static void float4x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -388,7 +388,7 @@ public static void float4x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_greater_equal_wide_wide()
         {
             float4x2 a0 = float4x2(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f);
@@ -412,7 +412,7 @@ public static void float4x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_greater_equal_wide_scalar()
         {
             float4x2 a0 = float4x2(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f);
@@ -436,7 +436,7 @@ public static void float4x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -460,7 +460,7 @@ public static void float4x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_add_wide_wide()
         {
             float4x2 a0 = float4x2(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f);
@@ -484,7 +484,7 @@ public static void float4x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_add_wide_scalar()
         {
             float4x2 a0 = float4x2(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f);
@@ -508,7 +508,7 @@ public static void float4x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -532,7 +532,7 @@ public static void float4x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_sub_wide_wide()
         {
             float4x2 a0 = float4x2(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f);
@@ -556,7 +556,7 @@ public static void float4x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_sub_wide_scalar()
         {
             float4x2 a0 = float4x2(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f);
@@ -580,7 +580,7 @@ public static void float4x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -604,7 +604,7 @@ public static void float4x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_mul_wide_wide()
         {
             float4x2 a0 = float4x2(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f);
@@ -628,7 +628,7 @@ public static void float4x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_mul_wide_scalar()
         {
             float4x2 a0 = float4x2(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f);
@@ -652,7 +652,7 @@ public static void float4x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -676,7 +676,7 @@ public static void float4x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_div_wide_wide()
         {
             float4x2 a0 = float4x2(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f);
@@ -700,7 +700,7 @@ public static void float4x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_div_wide_scalar()
         {
             float4x2 a0 = float4x2(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f);
@@ -724,7 +724,7 @@ public static void float4x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -748,7 +748,7 @@ public static void float4x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_mod_wide_wide()
         {
             float4x2 a0 = float4x2(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f);
@@ -772,7 +772,7 @@ public static void float4x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_mod_wide_scalar()
         {
             float4x2 a0 = float4x2(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f);
@@ -796,7 +796,7 @@ public static void float4x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -820,7 +820,7 @@ public static void float4x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_plus()
         {
             float4x2 a0 = float4x2(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f);
@@ -840,7 +840,7 @@ public static void float4x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_neg()
         {
             float4x2 a0 = float4x2(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f);
@@ -860,7 +860,7 @@ public static void float4x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_prefix_inc()
         {
             float4x2 a0 = float4x2(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f);
@@ -880,7 +880,7 @@ public static void float4x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_postfix_inc()
         {
             float4x2 a0 = float4x2(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f);
@@ -900,7 +900,7 @@ public static void float4x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_prefix_dec()
         {
             float4x2 a0 = float4x2(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f);
@@ -920,7 +920,7 @@ public static void float4x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x2_operator_postfix_dec()
         {
             float4x2 a0 = float4x2(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f);
@@ -940,7 +940,7 @@ public static void float4x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void float4x2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new float4x2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestFloat4x3.gen.cs b/src/Tests/Tests/Shared/TestFloat4x3.gen.cs
index f14618d1..06fb08a0 100644
--- a/src/Tests/Tests/Shared/TestFloat4x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat4x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat4x3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_zero()
         {
             TestUtils.AreEqual(0.0f, float4x3.zero.c0.x);
@@ -32,7 +32,7 @@ public static void float4x3_zero()
             TestUtils.AreEqual(0.0f, float4x3.zero.c2.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_equal_wide_wide()
         {
             float4x3 a0 = float4x3(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f, 163.232117f, -165.271f, 470.8777f, -423.942566f);
@@ -56,7 +56,7 @@ public static void float4x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_equal_wide_scalar()
         {
             float4x3 a0 = float4x3(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f, -57.4773865f, -182.049744f, 406.513733f, 370.886f);
@@ -80,7 +80,7 @@ public static void float4x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -104,7 +104,7 @@ public static void float4x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_not_equal_wide_wide()
         {
             float4x3 a0 = float4x3(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f, -203.301971f, -505.763245f, 162.17218f, 1.156189f);
@@ -128,7 +128,7 @@ public static void float4x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_not_equal_wide_scalar()
         {
             float4x3 a0 = float4x3(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f, -386.611176f, -281.021f, -270.26886f, -403.9637f);
@@ -152,7 +152,7 @@ public static void float4x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -176,7 +176,7 @@ public static void float4x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_less_wide_wide()
         {
             float4x3 a0 = float4x3(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f, 164.678833f, -350.9449f, 3.84143066f, 125.409729f);
@@ -200,7 +200,7 @@ public static void float4x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_less_wide_scalar()
         {
             float4x3 a0 = float4x3(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f, -20.4526062f, 225.2915f, 307.4842f, 274.015259f);
@@ -224,7 +224,7 @@ public static void float4x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -248,7 +248,7 @@ public static void float4x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_greater_wide_wide()
         {
             float4x3 a0 = float4x3(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f, -24.74054f, 319.782654f, -120.158569f, -289.008575f);
@@ -272,7 +272,7 @@ public static void float4x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_greater_wide_scalar()
         {
             float4x3 a0 = float4x3(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f, -405.7846f, 171.565369f, -241.807281f, 333.5782f);
@@ -296,7 +296,7 @@ public static void float4x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -320,7 +320,7 @@ public static void float4x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_less_equal_wide_wide()
         {
             float4x3 a0 = float4x3(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f, 458.530273f, -294.064758f, 23.62262f, -34.2840576f);
@@ -344,7 +344,7 @@ public static void float4x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_less_equal_wide_scalar()
         {
             float4x3 a0 = float4x3(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f, -1.35775757f, -268.899475f, 398.991943f, -471.253082f);
@@ -368,7 +368,7 @@ public static void float4x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -392,7 +392,7 @@ public static void float4x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_greater_equal_wide_wide()
         {
             float4x3 a0 = float4x3(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f, 456.9688f, -211.010162f, 182.411377f, -53.59604f);
@@ -416,7 +416,7 @@ public static void float4x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_greater_equal_wide_scalar()
         {
             float4x3 a0 = float4x3(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f, 393.278076f, -315.701538f, 441.011536f, -509.781555f);
@@ -440,7 +440,7 @@ public static void float4x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -464,7 +464,7 @@ public static void float4x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_add_wide_wide()
         {
             float4x3 a0 = float4x3(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f, 462.4137f, -46.17871f, 401.170044f, -454.124146f);
@@ -488,7 +488,7 @@ public static void float4x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_add_wide_scalar()
         {
             float4x3 a0 = float4x3(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f, -242.118744f, 82.50134f, 6.79937744f, -484.6998f);
@@ -512,7 +512,7 @@ public static void float4x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -536,7 +536,7 @@ public static void float4x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_sub_wide_wide()
         {
             float4x3 a0 = float4x3(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f, 317.706848f, 447.060425f, -489.074158f, -230.008392f);
@@ -560,7 +560,7 @@ public static void float4x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_sub_wide_scalar()
         {
             float4x3 a0 = float4x3(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f, 480.857971f, 16.3381958f, -366.865448f, -35.5231f);
@@ -584,7 +584,7 @@ public static void float4x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -608,7 +608,7 @@ public static void float4x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_mul_wide_wide()
         {
             float4x3 a0 = float4x3(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f, 45.8687744f, 363.3261f, -328.118958f, -471.023071f);
@@ -632,7 +632,7 @@ public static void float4x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_mul_wide_scalar()
         {
             float4x3 a0 = float4x3(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f, -338.29248f, 53.7962646f, 243.757324f, 135.354675f);
@@ -656,7 +656,7 @@ public static void float4x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -680,7 +680,7 @@ public static void float4x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_div_wide_wide()
         {
             float4x3 a0 = float4x3(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f, -237.69455f, -432.546875f, 200.2655f, 361.4416f);
@@ -704,7 +704,7 @@ public static void float4x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_div_wide_scalar()
         {
             float4x3 a0 = float4x3(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f, 146.466858f, -499.843567f, 58.68634f, -453.2058f);
@@ -728,7 +728,7 @@ public static void float4x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -752,7 +752,7 @@ public static void float4x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_mod_wide_wide()
         {
             float4x3 a0 = float4x3(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f, 335.271f, -503.608521f, 191.022522f, 289.742676f);
@@ -776,7 +776,7 @@ public static void float4x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_mod_wide_scalar()
         {
             float4x3 a0 = float4x3(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f, 335.166138f, 101.706482f, 319.4715f, -285.4023f);
@@ -800,7 +800,7 @@ public static void float4x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -824,7 +824,7 @@ public static void float4x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_plus()
         {
             float4x3 a0 = float4x3(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f, -386.059845f, 4.95440674f, -418.645264f, 504.474854f);
@@ -844,7 +844,7 @@ public static void float4x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_neg()
         {
             float4x3 a0 = float4x3(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f, -299.093384f, -383.014069f, 407.709778f, 168.735474f);
@@ -864,7 +864,7 @@ public static void float4x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_prefix_inc()
         {
             float4x3 a0 = float4x3(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f, 362.212769f, 401.6148f, 130.90918f, -450.230164f);
@@ -884,7 +884,7 @@ public static void float4x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_postfix_inc()
         {
             float4x3 a0 = float4x3(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f, 167.852112f, 147.94397f, -326.1076f, 41.03357f);
@@ -904,7 +904,7 @@ public static void float4x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_prefix_dec()
         {
             float4x3 a0 = float4x3(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f, 125.109619f, 469.844727f, 45.5366821f, 376.046875f);
@@ -924,7 +924,7 @@ public static void float4x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x3_operator_postfix_dec()
         {
             float4x3 a0 = float4x3(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f, -27.8892212f, -100.761841f, 156.14032f, 479.9452f);
@@ -944,7 +944,7 @@ public static void float4x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void float4x3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new float4x3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestFloat4x4.gen.cs b/src/Tests/Tests/Shared/TestFloat4x4.gen.cs
index cc444939..d7c82665 100644
--- a/src/Tests/Tests/Shared/TestFloat4x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat4x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat4x4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_zero()
         {
             TestUtils.AreEqual(0.0f, float4x4.zero.c0.x);
@@ -36,7 +36,7 @@ public static void float4x4_zero()
             TestUtils.AreEqual(0.0f, float4x4.zero.c3.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_identity()
         {
             TestUtils.AreEqual(1.0f, float4x4.identity.c0.x);
@@ -57,7 +57,7 @@ public static void float4x4_identity()
             TestUtils.AreEqual(1.0f, float4x4.identity.c3.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_equal_wide_wide()
         {
             float4x4 a0 = float4x4(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f, 163.232117f, -165.271f, 470.8777f, -423.942566f, 109.6344f, 462.6903f, -335.38147f, 357.2345f);
@@ -81,7 +81,7 @@ public static void float4x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_equal_wide_scalar()
         {
             float4x4 a0 = float4x4(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f, -57.4773865f, -182.049744f, 406.513733f, 370.886f, -172.035309f, 455.400024f, -11.3389893f, 363.938232f);
@@ -105,7 +105,7 @@ public static void float4x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -129,7 +129,7 @@ public static void float4x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_not_equal_wide_wide()
         {
             float4x4 a0 = float4x4(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f, -203.301971f, -505.763245f, 162.17218f, 1.156189f, 65.66205f, 102.787781f, 172.930054f, 26.6210327f);
@@ -153,7 +153,7 @@ public static void float4x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_not_equal_wide_scalar()
         {
             float4x4 a0 = float4x4(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f, -386.611176f, -281.021f, -270.26886f, -403.9637f, -269.805725f, 299.654236f, -71.7509155f, -432.755737f);
@@ -177,7 +177,7 @@ public static void float4x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -201,7 +201,7 @@ public static void float4x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_less_wide_wide()
         {
             float4x4 a0 = float4x4(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f, 164.678833f, -350.9449f, 3.84143066f, 125.409729f, -111.129944f, 70.00549f, 448.1983f, -419.987122f);
@@ -225,7 +225,7 @@ public static void float4x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_less_wide_scalar()
         {
             float4x4 a0 = float4x4(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f, -20.4526062f, 225.2915f, 307.4842f, 274.015259f, 373.549683f, 398.523682f, 105.030151f, -58.0108948f);
@@ -249,7 +249,7 @@ public static void float4x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -273,7 +273,7 @@ public static void float4x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_greater_wide_wide()
         {
             float4x4 a0 = float4x4(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f, -24.74054f, 319.782654f, -120.158569f, -289.008575f, 455.85144f, 144.706909f, 63.9320068f, -285.683044f);
@@ -297,7 +297,7 @@ public static void float4x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_greater_wide_scalar()
         {
             float4x4 a0 = float4x4(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f, -405.7846f, 171.565369f, -241.807281f, 333.5782f, 370.279175f, -413.7014f, -356.592346f, -353.0313f);
@@ -321,7 +321,7 @@ public static void float4x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -345,7 +345,7 @@ public static void float4x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_less_equal_wide_wide()
         {
             float4x4 a0 = float4x4(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f, 458.530273f, -294.064758f, 23.62262f, -34.2840576f, 149.736511f, -418.8867f, -197.502533f, -88.2055054f);
@@ -369,7 +369,7 @@ public static void float4x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_less_equal_wide_scalar()
         {
             float4x4 a0 = float4x4(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f, -1.35775757f, -268.899475f, 398.991943f, -471.253082f, -264.9378f, 82.2583f, 11.2460327f, 424.704041f);
@@ -393,7 +393,7 @@ public static void float4x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -417,7 +417,7 @@ public static void float4x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_greater_equal_wide_wide()
         {
             float4x4 a0 = float4x4(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f, 456.9688f, -211.010162f, 182.411377f, -53.59604f, -309.570221f, -136.022491f, 280.736267f, -96.99588f);
@@ -441,7 +441,7 @@ public static void float4x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_greater_equal_wide_scalar()
         {
             float4x4 a0 = float4x4(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f, 393.278076f, -315.701538f, 441.011536f, -509.781555f, -36.9942932f, 494.8203f, -164.973938f, -466.1201f);
@@ -465,7 +465,7 @@ public static void float4x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -489,7 +489,7 @@ public static void float4x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_add_wide_wide()
         {
             float4x4 a0 = float4x4(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f, 462.4137f, -46.17871f, 401.170044f, -454.124146f, 69.19568f, -177.957336f, 299.604126f, 340.704834f);
@@ -513,7 +513,7 @@ public static void float4x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_add_wide_scalar()
         {
             float4x4 a0 = float4x4(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f, -242.118744f, 82.50134f, 6.79937744f, -484.6998f, -188.265015f, -213.526733f, -267.7843f, 189.259949f);
@@ -537,7 +537,7 @@ public static void float4x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -561,7 +561,7 @@ public static void float4x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_sub_wide_wide()
         {
             float4x4 a0 = float4x4(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f, 317.706848f, 447.060425f, -489.074158f, -230.008392f, 24.8754272f, 366.614441f, -107.374146f, -219.008148f);
@@ -585,7 +585,7 @@ public static void float4x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_sub_wide_scalar()
         {
             float4x4 a0 = float4x4(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f, 480.857971f, 16.3381958f, -366.865448f, -35.5231f, 349.397766f, 439.077271f, 490.2223f, 195.024048f);
@@ -609,7 +609,7 @@ public static void float4x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -633,7 +633,7 @@ public static void float4x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_mul_wide_wide()
         {
             float4x4 a0 = float4x4(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f, 45.8687744f, 363.3261f, -328.118958f, -471.023071f, -262.682556f, -379.262756f, -374.090576f, 481.4474f);
@@ -657,7 +657,7 @@ public static void float4x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_mul_wide_scalar()
         {
             float4x4 a0 = float4x4(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f, -338.29248f, 53.7962646f, 243.757324f, 135.354675f, -207.3501f, -383.9396f, -31.4252319f, 42.6761475f);
@@ -681,7 +681,7 @@ public static void float4x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -705,7 +705,7 @@ public static void float4x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_div_wide_wide()
         {
             float4x4 a0 = float4x4(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f, -237.69455f, -432.546875f, 200.2655f, 361.4416f, -416.226135f, -450.0192f, -273.497437f, -286.908173f);
@@ -729,7 +729,7 @@ public static void float4x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_div_wide_scalar()
         {
             float4x4 a0 = float4x4(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f, 146.466858f, -499.843567f, 58.68634f, -453.2058f, -205.033813f, 481.738159f, 464.479065f, -293.4635f);
@@ -753,7 +753,7 @@ public static void float4x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -777,7 +777,7 @@ public static void float4x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_mod_wide_wide()
         {
             float4x4 a0 = float4x4(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f, 335.271f, -503.608521f, 191.022522f, 289.742676f, -124.033722f, 259.274f, -274.358459f, -140.030792f);
@@ -801,7 +801,7 @@ public static void float4x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_mod_wide_scalar()
         {
             float4x4 a0 = float4x4(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f, 335.166138f, 101.706482f, 319.4715f, -285.4023f, -355.846863f, 259.378f, -330.871948f, -284.343567f);
@@ -825,7 +825,7 @@ public static void float4x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -849,7 +849,7 @@ public static void float4x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_plus()
         {
             float4x4 a0 = float4x4(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f, -386.059845f, 4.95440674f, -418.645264f, 504.474854f, -170.746521f, 439.5594f, -478.7494f, 116.400757f);
@@ -869,7 +869,7 @@ public static void float4x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_neg()
         {
             float4x4 a0 = float4x4(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f, -299.093384f, -383.014069f, 407.709778f, 168.735474f, 466.441528f, 171.902466f, -280.558319f, -78.857605f);
@@ -889,7 +889,7 @@ public static void float4x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_prefix_inc()
         {
             float4x4 a0 = float4x4(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f, 362.212769f, 401.6148f, 130.90918f, -450.230164f, 243.546936f, 46.1920166f, -41.4972839f, 299.1855f);
@@ -909,7 +909,7 @@ public static void float4x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_postfix_inc()
         {
             float4x4 a0 = float4x4(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f, 167.852112f, 147.94397f, -326.1076f, 41.03357f, 128.5304f, 73.15558f, -60.1323853f, -446.229767f);
@@ -929,7 +929,7 @@ public static void float4x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_prefix_dec()
         {
             float4x4 a0 = float4x4(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f, 125.109619f, 469.844727f, 45.5366821f, 376.046875f, -363.0755f, -22.0289612f, 248.7901f, 168.095032f);
@@ -949,7 +949,7 @@ public static void float4x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_operator_postfix_dec()
         {
             float4x4 a0 = float4x4(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f, -27.8892212f, -100.761841f, 156.14032f, 479.9452f, -200.304291f, -445.026947f, 407.420349f, 327.670349f);
@@ -969,7 +969,7 @@ public static void float4x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void float4x4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new float4x4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestHalf.cs b/src/Tests/Tests/Shared/TestHalf.cs
index 7cd3e330..301e06d2 100644
--- a/src/Tests/Tests/Shared/TestHalf.cs
+++ b/src/Tests/Tests/Shared/TestHalf.cs
@@ -8,20 +8,20 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public partial class TestHalf
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half_zero()
         {
             TestUtils.AreEqual(0x0000, half.zero.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half2_zero()
         {
             TestUtils.AreEqual(0x0000, half2.zero.x.value);
             TestUtils.AreEqual(0x0000, half2.zero.y.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half3_zero()
         {
             TestUtils.AreEqual(0x0000, half3.zero.x.value);
@@ -29,7 +29,7 @@ public static void half3_zero()
             TestUtils.AreEqual(0x0000, half3.zero.z.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half4_zero()
         {
             TestUtils.AreEqual(0x0000, half4.zero.x.value);
@@ -38,7 +38,7 @@ public static void half4_zero()
             TestUtils.AreEqual(0x0000, half4.zero.w.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half_from_float_construction()
         {
             TestUtils.AreEqual(0x0000, half(0.0f).value);
@@ -58,14 +58,14 @@ public static void half_from_float_construction()
             TestUtils.AreEqual(0xFC00, half(float.NegativeInfinity).value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void half_from_float_construction_signed_zero()
         {
             TestUtils.AreEqual(0x8000, half(TestUtils.SignedFloatZero()).value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half2_from_float2_construction()
         {
             half2 h0 = half2(float2(0.0f, 2.98e-08f));
@@ -89,7 +89,7 @@ public static void half2_from_float2_construction()
             TestUtils.AreEqual(uint2(0xFC00, 0x0000), uint2(h7.x.value, h7.y.value));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void half2_from_float2_construction_signed_zero()
         {
@@ -97,7 +97,7 @@ public static void half2_from_float2_construction_signed_zero()
             TestUtils.AreEqual(uint2(0x8000, 0x8000), uint2(h0.x.value, h0.y.value));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half3_from_float3_construction()
         {
             half3 h0 = half3(float3(0.0f, 2.98e-08f, 5.96046448e-08f));
@@ -114,7 +114,7 @@ public static void half3_from_float3_construction()
             TestUtils.AreEqual(uint3(0xFC00, 0xFC00, 0x0000), uint3(h4.x.value, h4.y.value, h4.z.value));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void half3_from_float3_construction_signed_zero()
         {
@@ -122,7 +122,7 @@ public static void half3_from_float3_construction_signed_zero()
             TestUtils.AreEqual(uint3(0x8000, 0x8000, 0x8000), uint3(h0.x.value, h0.y.value, h0.z.value));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half4_from_float4_construction()
         {
             half4 h0 = half4(float4(0.0f, 2.98e-08f, 5.96046448e-08f, 123.4f));
@@ -136,7 +136,7 @@ public static void half4_from_float4_construction()
             TestUtils.AreEqual(uint4(0xFC00, 0xFC00, 0xFC00, 0x0000), uint4(h3.x.value, h3.y.value, h3.z.value, h3.w.value));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void half4_from_float4_construction_signed_zero()
         {
@@ -145,7 +145,7 @@ public static void half4_from_float4_construction_signed_zero()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half_from_double_construction()
         {
             TestUtils.AreEqual(0x0000, half(0.0).value);
@@ -165,14 +165,14 @@ public static void half_from_double_construction()
             TestUtils.AreEqual(0xFC00, half(double.NegativeInfinity).value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void half_from_double_construction_signed_zero()
         {
             TestUtils.AreEqual(0x8000, half(TestUtils.SignedDoubleZero()).value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half2_from_double2_construction()
         {
             half2 h0 = half2(double2(0.0, 2.98e-08));
@@ -196,7 +196,7 @@ public static void half2_from_double2_construction()
             TestUtils.AreEqual(uint2(0xFC00, 0x0000), uint2(h7.x.value, h7.y.value));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void half2_from_double2_construction_signed_zero()
         {
@@ -204,7 +204,7 @@ public static void half2_from_double2_construction_signed_zero()
             TestUtils.AreEqual(uint2(0x8000, 0x8000), uint2(h0.x.value, h0.y.value));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half3_from_double3_construction()
         {
             half3 h0 = half3(double3(0.0, 2.98e-08, 5.96046448e-08));
@@ -221,7 +221,7 @@ public static void half3_from_double3_construction()
             TestUtils.AreEqual(uint3(0xFC00, 0xFC00, 0x0000), uint3(h4.x.value, h4.y.value, h4.z.value));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void half3_from_double3_construction_signed_zero()
         {
@@ -229,7 +229,7 @@ public static void half3_from_double3_construction_signed_zero()
             TestUtils.AreEqual(uint3(0x8000, 0x8000, 0x8000), uint3(h0.x.value, h0.y.value, h0.z.value));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half4_from_double4_construction()
         {
             half4 h0 = half4(double4(0.0, 2.98e-08, 5.96046448e-08, 123.4));
@@ -243,7 +243,7 @@ public static void half4_from_double4_construction()
             TestUtils.AreEqual(uint4(0xFC00, 0xFC00, 0xFC00, 0x0000), uint4(h3.x.value, h3.y.value, h3.z.value, h3.w.value));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void half4_from_double4_construction_signed_zero()
         {
@@ -251,7 +251,7 @@ public static void half4_from_double4_construction_signed_zero()
             TestUtils.AreEqual(uint4(0x8000, 0x8000, 0x8000, 0x8000), uint4(h0.x.value, h0.y.value, h0.z.value, h0.w.value));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half_to_float()
         {
             TestUtils.AreEqual(0x00000000, asuint(new half { value = 0x0000 }));
@@ -269,7 +269,7 @@ public static void half_to_float()
             TestUtils.AreEqual(true, isnan(new half { value = 0xFC01 }));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half2_to_float2()
         {
             half2 h0; h0.x.value = 0x0000; h0.y.value = 0x0203;
@@ -293,7 +293,7 @@ public static void half2_to_float2()
             TestUtils.AreEqual(true, all(isnan(h7)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half3_to_float3()
         {
             half3 h0; h0.x.value = 0x0000; h0.y.value = 0x0203; h0.z.value = 0x4321;
@@ -313,7 +313,7 @@ public static void half3_to_float3()
             TestUtils.AreEqual(true, all(isnan(h5)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half4_to_float4()
         {
             half4 h0; h0.x.value = 0x0000; h0.y.value = 0x0203; h0.z.value = 0x4321; h0.w.value = 0x7BFF;
@@ -334,7 +334,7 @@ public static void half4_to_float4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half_to_double()
         {
             TestUtils.AreEqual(0x0000000000000000u, asulong((double)new half { value = 0x0000 }));
@@ -353,14 +353,14 @@ public static void half_to_double()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half_from_float_explicit_conversion()
         {
             half h = (half)123.4f;
             TestUtils.AreEqual(0x57B6, h.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half2_from_float2_explicit_conversion()
         {
             half2 h = (half2)float2(123.4f, 5.96046448e-08f);
@@ -368,7 +368,7 @@ public static void half2_from_float2_explicit_conversion()
             TestUtils.AreEqual(0x0001, h.y.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half3_from_float3_explicit_conversion()
         {
             half3 h = (half3)float3(123.4f, 5.96046448e-08f, -65504.0f);
@@ -377,7 +377,7 @@ public static void half3_from_float3_explicit_conversion()
             TestUtils.AreEqual(0xFBFF, h.z.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half4_from_float4_explicit_conversion()
         {
             half4 h = (half4)float4(123.4f, 5.96046448e-08f, -65504.0f, float.PositiveInfinity);
@@ -387,7 +387,7 @@ public static void half4_from_float4_explicit_conversion()
             TestUtils.AreEqual(0x7C00, h.w.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half_from_double_explicit_conversion()
         {
             half h = (half)123.4;
@@ -395,7 +395,7 @@ public static void half_from_double_explicit_conversion()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half_to_float_implicit_conversion()
         {
             half h; h.value = 0x0203;
@@ -403,7 +403,7 @@ public static void half_to_float_implicit_conversion()
             TestUtils.AreEqual(0x3800C000, asuint(f));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half2_to_float2_implicit_conversion()
         {
             half2 h; h.x.value = 0x0203;    h.y.value = 0x8203;
@@ -412,7 +412,7 @@ public static void half2_to_float2_implicit_conversion()
             TestUtils.AreEqual(0xB800C000, asuint(f.y));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half3_to_float3_implicit_conversion()
         {
             half3 h; h.x.value = 0x0203; h.y.value = 0x8203; h.z.value = 0x7BFF;
@@ -422,7 +422,7 @@ public static void half3_to_float3_implicit_conversion()
             TestUtils.AreEqual(0x477FE000, asuint(f.z));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half4_to_float4_implicit_conversion()
         {
             half4 h; h.x.value = 0x0203; h.y.value = 0x8203; h.z.value = 0x7BFF; h.w.value = 0x7C00;
@@ -433,7 +433,7 @@ public static void half4_to_float4_implicit_conversion()
             TestUtils.AreEqual(0x7F800000, asuint(f.w));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half_to_double_implicit_conversion()
         {
             half h; h.value = 0x0203;
@@ -442,33 +442,33 @@ public static void half_to_double_implicit_conversion()
             TestUtils.AreEqual(0x3F00180000000000u, asulong(f));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half_minvalue()
         {
             half min = new half(half.MinValue);
             TestUtils.AreEqual(0xfbff, min.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half_maxvalue()
         {
             half max = new half(half.MaxValue);
             TestUtils.AreEqual(0x7bff, max.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half_minvalueashalf()
         {
             TestUtils.AreEqual(0xfbff, half.MinValueAsHalf.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half_maxvalueashalf()
         {
             TestUtils.AreEqual(0x7bff, half.MaxValueAsHalf.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half2_minvalue()
         {
             half2 min = half.MinValueAsHalf;
@@ -476,7 +476,7 @@ public static void half2_minvalue()
             TestUtils.AreEqual(0xfbff, min.y.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half2_maxvalue()
         {
             half2 max = half.MaxValueAsHalf;
@@ -484,7 +484,7 @@ public static void half2_maxvalue()
             TestUtils.AreEqual(0x7bff, max.y.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half3_minvalue()
         {
             half3 min = half.MinValueAsHalf;
@@ -493,7 +493,7 @@ public static void half3_minvalue()
             TestUtils.AreEqual(0xfbff, min.z.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half3_maxvalue()
         {
             half3 max = half.MaxValueAsHalf;
@@ -502,7 +502,7 @@ public static void half3_maxvalue()
             TestUtils.AreEqual(0x7bff, max.z.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half4_minvalue()
         {
             half4 min = half.MinValueAsHalf;
@@ -512,7 +512,7 @@ public static void half4_minvalue()
             TestUtils.AreEqual(0xfbff, min.w.value);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void half4_maxvalue()
         {
             half4 max = half.MaxValueAsHalf;
diff --git a/src/Tests/Tests/Shared/TestInt2.gen.cs b/src/Tests/Tests/Shared/TestInt2.gen.cs
index 78c07923..6196c993 100644
--- a/src/Tests/Tests/Shared/TestInt2.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt2.gen.cs
@@ -15,14 +15,14 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_zero()
         {
             TestUtils.AreEqual(0, int2.zero.x);
             TestUtils.AreEqual(0, int2.zero.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_constructor()
         {
             int2 a = new int2(1, 2);
@@ -30,7 +30,7 @@ public static void int2_constructor()
             TestUtils.AreEqual(2, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_scalar_constructor()
         {
             int2 a = new int2(17);
@@ -38,7 +38,7 @@ public static void int2_scalar_constructor()
             TestUtils.AreEqual(17, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_static_constructor()
         {
             int2 a = int2(1, 2);
@@ -46,7 +46,7 @@ public static void int2_static_constructor()
             TestUtils.AreEqual(2, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_static_scalar_constructor()
         {
             int2 a = int2(17);
@@ -54,7 +54,7 @@ public static void int2_static_scalar_constructor()
             TestUtils.AreEqual(17, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_equal_wide_wide()
         {
             int2 a0 = int2(2105871082, 35218899);
@@ -78,7 +78,7 @@ public static void int2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_equal_wide_scalar()
         {
             int2 a0 = int2(437822262, 2020661134);
@@ -102,7 +102,7 @@ public static void int2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -126,7 +126,7 @@ public static void int2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_not_equal_wide_wide()
         {
             int2 a0 = int2(1977284100, 1293292704);
@@ -150,7 +150,7 @@ public static void int2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_not_equal_wide_scalar()
         {
             int2 a0 = int2(1038269360, 1427812625);
@@ -174,7 +174,7 @@ public static void int2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -198,7 +198,7 @@ public static void int2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_less_wide_wide()
         {
             int2 a0 = int2(1486550609, 1779244308);
@@ -222,7 +222,7 @@ public static void int2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_less_wide_scalar()
         {
             int2 a0 = int2(796797557, 670113454);
@@ -246,7 +246,7 @@ public static void int2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -270,7 +270,7 @@ public static void int2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_greater_wide_wide()
         {
             int2 a0 = int2(2087717754, 1725569452);
@@ -294,7 +294,7 @@ public static void int2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_greater_wide_scalar()
         {
             int2 a0 = int2(1208626274, 239697208);
@@ -318,7 +318,7 @@ public static void int2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -342,7 +342,7 @@ public static void int2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_less_equal_wide_wide()
         {
             int2 a0 = int2(154092149, 1515170149);
@@ -366,7 +366,7 @@ public static void int2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_less_equal_wide_scalar()
         {
             int2 a0 = int2(1479531977, 1427983411);
@@ -390,7 +390,7 @@ public static void int2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -414,7 +414,7 @@ public static void int2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_greater_equal_wide_wide()
         {
             int2 a0 = int2(8538378, 2131749726);
@@ -438,7 +438,7 @@ public static void int2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_greater_equal_wide_scalar()
         {
             int2 a0 = int2(2049236663, 182691143);
@@ -462,7 +462,7 @@ public static void int2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -486,7 +486,7 @@ public static void int2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_add_wide_wide()
         {
             int2 a0 = int2(2135171378, 21433296);
@@ -510,7 +510,7 @@ public static void int2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_add_wide_scalar()
         {
             int2 a0 = int2(665815972, 1783729250);
@@ -534,7 +534,7 @@ public static void int2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -558,7 +558,7 @@ public static void int2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_sub_wide_wide()
         {
             int2 a0 = int2(1410318491, 1097280168);
@@ -582,7 +582,7 @@ public static void int2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_sub_wide_scalar()
         {
             int2 a0 = int2(1508669340, 1594795463);
@@ -606,7 +606,7 @@ public static void int2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -630,7 +630,7 @@ public static void int2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_mul_wide_wide()
         {
             int2 a0 = int2(61417577, 219585476);
@@ -654,7 +654,7 @@ public static void int2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_mul_wide_scalar()
         {
             int2 a0 = int2(871746615, 492532311);
@@ -678,7 +678,7 @@ public static void int2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -702,7 +702,7 @@ public static void int2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_div_wide_wide()
         {
             int2 a0 = int2(333171510, 858154903);
@@ -726,7 +726,7 @@ public static void int2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_div_wide_scalar()
         {
             int2 a0 = int2(1433072926, 1073958635);
@@ -750,7 +750,7 @@ public static void int2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -774,7 +774,7 @@ public static void int2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_mod_wide_wide()
         {
             int2 a0 = int2(258342924, 1454754891);
@@ -798,7 +798,7 @@ public static void int2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_mod_wide_scalar()
         {
             int2 a0 = int2(560988938, 629524514);
@@ -822,7 +822,7 @@ public static void int2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -846,7 +846,7 @@ public static void int2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_plus()
         {
             int2 a0 = int2(195392567, 222719748);
@@ -866,7 +866,7 @@ public static void int2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_neg()
         {
             int2 a0 = int2(1385088677, 94114564);
@@ -886,7 +886,7 @@ public static void int2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_prefix_inc()
         {
             int2 a0 = int2(780471723, 954741756);
@@ -906,7 +906,7 @@ public static void int2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_postfix_inc()
         {
             int2 a0 = int2(241865086, 2145821641);
@@ -926,7 +926,7 @@ public static void int2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_prefix_dec()
         {
             int2 a0 = int2(1331961415, 1612382200);
@@ -946,7 +946,7 @@ public static void int2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_postfix_dec()
         {
             int2 a0 = int2(1870005937, 1708534798);
@@ -966,7 +966,7 @@ public static void int2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_bitwise_and_wide_wide()
         {
             int2 a0 = int2(1055241304, 859321394);
@@ -990,7 +990,7 @@ public static void int2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_bitwise_and_wide_scalar()
         {
             int2 a0 = int2(1513158868, 284695609);
@@ -1014,7 +1014,7 @@ public static void int2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1038,7 +1038,7 @@ public static void int2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_bitwise_or_wide_wide()
         {
             int2 a0 = int2(1920951869, 1750772852);
@@ -1062,7 +1062,7 @@ public static void int2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_bitwise_or_wide_scalar()
         {
             int2 a0 = int2(1295304853, 1307252624);
@@ -1086,7 +1086,7 @@ public static void int2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1110,7 +1110,7 @@ public static void int2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_bitwise_xor_wide_wide()
         {
             int2 a0 = int2(1843655608, 362425681);
@@ -1134,7 +1134,7 @@ public static void int2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_bitwise_xor_wide_scalar()
         {
             int2 a0 = int2(169345668, 176087064);
@@ -1158,7 +1158,7 @@ public static void int2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1182,7 +1182,7 @@ public static void int2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_left_shift()
         {
             int2 a0 = int2(1129100049, 829482269);
@@ -1206,7 +1206,7 @@ public static void int2_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_right_shift()
         {
             int2 a0 = int2(809126085, 908563670);
@@ -1230,7 +1230,7 @@ public static void int2_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_operator_bitwise_not()
         {
             int2 a0 = int2(111796841, 603562399);
@@ -1250,7 +1250,7 @@ public static void int2_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_shuffle_result_1()
         {
             int2 a = int2(0, 1);
@@ -1262,7 +1262,7 @@ public static void int2_shuffle_result_1()
             TestUtils.AreEqual((3), shuffle(a, b, ShuffleComponent.RightY));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_shuffle_result_2()
         {
             int2 a = int2(0, 1);
@@ -1286,7 +1286,7 @@ public static void int2_shuffle_result_2()
             TestUtils.AreEqual(int2(3, 3), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_shuffle_result_3()
         {
             int2 a = int2(0, 1);
@@ -1310,7 +1310,7 @@ public static void int2_shuffle_result_3()
             TestUtils.AreEqual(int3(3, 1, 1), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_shuffle_result_4()
         {
             int2 a = int2(0, 1);
@@ -1334,7 +1334,7 @@ public static void int2_shuffle_result_4()
             TestUtils.AreEqual(int4(2, 0, 0, 0), shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX));
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void int2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new int2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestInt2x2.gen.cs b/src/Tests/Tests/Shared/TestInt2x2.gen.cs
index 517c4586..a99dd57e 100644
--- a/src/Tests/Tests/Shared/TestInt2x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt2x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt2x2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_zero()
         {
             TestUtils.AreEqual(0, int2x2.zero.c0.x);
@@ -24,7 +24,7 @@ public static void int2x2_zero()
             TestUtils.AreEqual(0, int2x2.zero.c1.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_identity()
         {
             TestUtils.AreEqual(1, int2x2.identity.c0.x);
@@ -33,7 +33,7 @@ public static void int2x2_identity()
             TestUtils.AreEqual(1, int2x2.identity.c1.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_equal_wide_wide()
         {
             int2x2 a0 = int2x2(2105871082, 35218899, 1550755093, 764676020);
@@ -57,7 +57,7 @@ public static void int2x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_equal_wide_scalar()
         {
             int2x2 a0 = int2x2(437822262, 2020661134, 541786900, 853113810);
@@ -81,7 +81,7 @@ public static void int2x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -105,7 +105,7 @@ public static void int2x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_not_equal_wide_wide()
         {
             int2x2 a0 = int2x2(1977284100, 1293292704, 1547283851, 422428953);
@@ -129,7 +129,7 @@ public static void int2x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_not_equal_wide_scalar()
         {
             int2x2 a0 = int2x2(1038269360, 1427812625, 103361237, 1347017023);
@@ -153,7 +153,7 @@ public static void int2x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -177,7 +177,7 @@ public static void int2x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_less_wide_wide()
         {
             int2x2 a0 = int2x2(1486550609, 1779244308, 1602148045, 1614085440);
@@ -201,7 +201,7 @@ public static void int2x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_less_wide_scalar()
         {
             int2x2 a0 = int2x2(796797557, 670113454, 933579492, 278884514);
@@ -225,7 +225,7 @@ public static void int2x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -249,7 +249,7 @@ public static void int2x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_greater_wide_wide()
         {
             int2x2 a0 = int2x2(2087717754, 1725569452, 1298066182, 1693943616);
@@ -273,7 +273,7 @@ public static void int2x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_greater_wide_scalar()
         {
             int2x2 a0 = int2x2(1208626274, 239697208, 1979453345, 1253474001);
@@ -297,7 +297,7 @@ public static void int2x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -321,7 +321,7 @@ public static void int2x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_less_equal_wide_wide()
         {
             int2x2 a0 = int2x2(154092149, 1515170149, 1083970332, 785807178);
@@ -345,7 +345,7 @@ public static void int2x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_less_equal_wide_scalar()
         {
             int2x2 a0 = int2x2(1479531977, 1427983411, 415250630, 1245345407);
@@ -369,7 +369,7 @@ public static void int2x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -393,7 +393,7 @@ public static void int2x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_greater_equal_wide_wide()
         {
             int2x2 a0 = int2x2(8538378, 2131749726, 265427108, 523609761);
@@ -417,7 +417,7 @@ public static void int2x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_greater_equal_wide_scalar()
         {
             int2x2 a0 = int2x2(2049236663, 182691143, 634973382, 1197012109);
@@ -441,7 +441,7 @@ public static void int2x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -465,7 +465,7 @@ public static void int2x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_add_wide_wide()
         {
             int2x2 a0 = int2x2(2135171378, 21433296, 1954723494, 683604307);
@@ -489,7 +489,7 @@ public static void int2x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_add_wide_scalar()
         {
             int2x2 a0 = int2x2(665815972, 1783729250, 1591678394, 1284528538);
@@ -513,7 +513,7 @@ public static void int2x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -537,7 +537,7 @@ public static void int2x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_sub_wide_wide()
         {
             int2x2 a0 = int2x2(1410318491, 1097280168, 1827039044, 28881338);
@@ -561,7 +561,7 @@ public static void int2x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_sub_wide_scalar()
         {
             int2x2 a0 = int2x2(1508669340, 1594795463, 266707545, 643102647);
@@ -585,7 +585,7 @@ public static void int2x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -609,7 +609,7 @@ public static void int2x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_mul_wide_wide()
         {
             int2x2 a0 = int2x2(61417577, 219585476, 1362520891, 1511084277);
@@ -633,7 +633,7 @@ public static void int2x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_mul_wide_scalar()
         {
             int2x2 a0 = int2x2(871746615, 492532311, 570557670, 2142306629);
@@ -657,7 +657,7 @@ public static void int2x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -681,7 +681,7 @@ public static void int2x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_div_wide_wide()
         {
             int2x2 a0 = int2x2(333171510, 858154903, 1181365836, 671357749);
@@ -705,7 +705,7 @@ public static void int2x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_div_wide_scalar()
         {
             int2x2 a0 = int2x2(1433072926, 1073958635, 1195142312, 536596719);
@@ -729,7 +729,7 @@ public static void int2x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -753,7 +753,7 @@ public static void int2x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_mod_wide_wide()
         {
             int2x2 a0 = int2x2(258342924, 1454754891, 723352342, 1981431473);
@@ -777,7 +777,7 @@ public static void int2x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_mod_wide_scalar()
         {
             int2x2 a0 = int2x2(560988938, 629524514, 767711194, 434281967);
@@ -801,7 +801,7 @@ public static void int2x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -825,7 +825,7 @@ public static void int2x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_plus()
         {
             int2x2 a0 = int2x2(195392567, 222719748, 1002351013, 1570765263);
@@ -845,7 +845,7 @@ public static void int2x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_neg()
         {
             int2x2 a0 = int2x2(1385088677, 94114564, 1350664872, 1458616659);
@@ -865,7 +865,7 @@ public static void int2x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_prefix_inc()
         {
             int2x2 a0 = int2x2(780471723, 954741756, 272723451, 2142862245);
@@ -885,7 +885,7 @@ public static void int2x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_postfix_inc()
         {
             int2x2 a0 = int2x2(241865086, 2145821641, 1596166022, 803592338);
@@ -905,7 +905,7 @@ public static void int2x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_prefix_dec()
         {
             int2x2 a0 = int2x2(1331961415, 1612382200, 1401591249, 2042075388);
@@ -925,7 +925,7 @@ public static void int2x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_postfix_dec()
         {
             int2x2 a0 = int2x2(1870005937, 1708534798, 704493460, 462940703);
@@ -945,7 +945,7 @@ public static void int2x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_bitwise_and_wide_wide()
         {
             int2x2 a0 = int2x2(1055241304, 859321394, 1088358961, 2090949513);
@@ -969,7 +969,7 @@ public static void int2x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_bitwise_and_wide_scalar()
         {
             int2x2 a0 = int2x2(1513158868, 284695609, 734595037, 1566510707);
@@ -993,7 +993,7 @@ public static void int2x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1017,7 +1017,7 @@ public static void int2x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_bitwise_or_wide_wide()
         {
             int2x2 a0 = int2x2(1920951869, 1750772852, 1420019191, 732977093);
@@ -1041,7 +1041,7 @@ public static void int2x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_bitwise_or_wide_scalar()
         {
             int2x2 a0 = int2x2(1295304853, 1307252624, 350194630, 1128063578);
@@ -1065,7 +1065,7 @@ public static void int2x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1089,7 +1089,7 @@ public static void int2x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_bitwise_xor_wide_wide()
         {
             int2x2 a0 = int2x2(1843655608, 362425681, 640805534, 1342040268);
@@ -1113,7 +1113,7 @@ public static void int2x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_bitwise_xor_wide_scalar()
         {
             int2x2 a0 = int2x2(169345668, 176087064, 2084362901, 1663924004);
@@ -1137,7 +1137,7 @@ public static void int2x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1161,7 +1161,7 @@ public static void int2x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_left_shift()
         {
             int2x2 a0 = int2x2(1129100049, 829482269, 1571297368, 443753193);
@@ -1185,7 +1185,7 @@ public static void int2x2_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_right_shift()
         {
             int2x2 a0 = int2x2(809126085, 908563670, 763568837, 1986717290);
@@ -1209,7 +1209,7 @@ public static void int2x2_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x2_operator_bitwise_not()
         {
             int2x2 a0 = int2x2(111796841, 603562399, 745091931, 853183268);
@@ -1229,7 +1229,7 @@ public static void int2x2_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void int2x2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new int2x2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestInt2x3.gen.cs b/src/Tests/Tests/Shared/TestInt2x3.gen.cs
index e6b88941..95b713de 100644
--- a/src/Tests/Tests/Shared/TestInt2x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt2x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt2x3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_zero()
         {
             TestUtils.AreEqual(0, int2x3.zero.c0.x);
@@ -26,7 +26,7 @@ public static void int2x3_zero()
             TestUtils.AreEqual(0, int2x3.zero.c2.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_equal_wide_wide()
         {
             int2x3 a0 = int2x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098);
@@ -50,7 +50,7 @@ public static void int2x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_equal_wide_scalar()
         {
             int2x3 a0 = int2x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405);
@@ -74,7 +74,7 @@ public static void int2x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -98,7 +98,7 @@ public static void int2x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_not_equal_wide_wide()
         {
             int2x3 a0 = int2x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892);
@@ -122,7 +122,7 @@ public static void int2x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_not_equal_wide_scalar()
         {
             int2x3 a0 = int2x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802);
@@ -146,7 +146,7 @@ public static void int2x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -170,7 +170,7 @@ public static void int2x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_less_wide_wide()
         {
             int2x3 a0 = int2x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342);
@@ -194,7 +194,7 @@ public static void int2x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_less_wide_scalar()
         {
             int2x3 a0 = int2x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673);
@@ -218,7 +218,7 @@ public static void int2x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -242,7 +242,7 @@ public static void int2x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_greater_wide_wide()
         {
             int2x3 a0 = int2x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491);
@@ -266,7 +266,7 @@ public static void int2x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_greater_wide_scalar()
         {
             int2x3 a0 = int2x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635);
@@ -290,7 +290,7 @@ public static void int2x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -314,7 +314,7 @@ public static void int2x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_less_equal_wide_wide()
         {
             int2x3 a0 = int2x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627);
@@ -338,7 +338,7 @@ public static void int2x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_less_equal_wide_scalar()
         {
             int2x3 a0 = int2x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632);
@@ -362,7 +362,7 @@ public static void int2x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -386,7 +386,7 @@ public static void int2x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_greater_equal_wide_wide()
         {
             int2x3 a0 = int2x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564);
@@ -410,7 +410,7 @@ public static void int2x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_greater_equal_wide_scalar()
         {
             int2x3 a0 = int2x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469);
@@ -434,7 +434,7 @@ public static void int2x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -458,7 +458,7 @@ public static void int2x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_add_wide_wide()
         {
             int2x3 a0 = int2x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995);
@@ -482,7 +482,7 @@ public static void int2x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_add_wide_scalar()
         {
             int2x3 a0 = int2x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732);
@@ -506,7 +506,7 @@ public static void int2x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -530,7 +530,7 @@ public static void int2x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_sub_wide_wide()
         {
             int2x3 a0 = int2x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868);
@@ -554,7 +554,7 @@ public static void int2x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_sub_wide_scalar()
         {
             int2x3 a0 = int2x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328);
@@ -578,7 +578,7 @@ public static void int2x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -602,7 +602,7 @@ public static void int2x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_mul_wide_wide()
         {
             int2x3 a0 = int2x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871);
@@ -626,7 +626,7 @@ public static void int2x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_mul_wide_scalar()
         {
             int2x3 a0 = int2x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563);
@@ -650,7 +650,7 @@ public static void int2x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -674,7 +674,7 @@ public static void int2x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_div_wide_wide()
         {
             int2x3 a0 = int2x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420);
@@ -698,7 +698,7 @@ public static void int2x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_div_wide_scalar()
         {
             int2x3 a0 = int2x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346);
@@ -722,7 +722,7 @@ public static void int2x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -746,7 +746,7 @@ public static void int2x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_mod_wide_wide()
         {
             int2x3 a0 = int2x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627);
@@ -770,7 +770,7 @@ public static void int2x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_mod_wide_scalar()
         {
             int2x3 a0 = int2x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846);
@@ -794,7 +794,7 @@ public static void int2x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -818,7 +818,7 @@ public static void int2x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_plus()
         {
             int2x3 a0 = int2x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277);
@@ -838,7 +838,7 @@ public static void int2x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_neg()
         {
             int2x3 a0 = int2x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493);
@@ -858,7 +858,7 @@ public static void int2x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_prefix_inc()
         {
             int2x3 a0 = int2x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550);
@@ -878,7 +878,7 @@ public static void int2x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_postfix_inc()
         {
             int2x3 a0 = int2x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229);
@@ -898,7 +898,7 @@ public static void int2x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_prefix_dec()
         {
             int2x3 a0 = int2x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159);
@@ -918,7 +918,7 @@ public static void int2x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_postfix_dec()
         {
             int2x3 a0 = int2x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869);
@@ -938,7 +938,7 @@ public static void int2x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_bitwise_and_wide_wide()
         {
             int2x3 a0 = int2x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515);
@@ -962,7 +962,7 @@ public static void int2x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_bitwise_and_wide_scalar()
         {
             int2x3 a0 = int2x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838);
@@ -986,7 +986,7 @@ public static void int2x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1010,7 +1010,7 @@ public static void int2x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_bitwise_or_wide_wide()
         {
             int2x3 a0 = int2x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930);
@@ -1034,7 +1034,7 @@ public static void int2x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_bitwise_or_wide_scalar()
         {
             int2x3 a0 = int2x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467);
@@ -1058,7 +1058,7 @@ public static void int2x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1082,7 +1082,7 @@ public static void int2x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_bitwise_xor_wide_wide()
         {
             int2x3 a0 = int2x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850);
@@ -1106,7 +1106,7 @@ public static void int2x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_bitwise_xor_wide_scalar()
         {
             int2x3 a0 = int2x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661);
@@ -1130,7 +1130,7 @@ public static void int2x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1154,7 +1154,7 @@ public static void int2x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_left_shift()
         {
             int2x3 a0 = int2x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593);
@@ -1178,7 +1178,7 @@ public static void int2x3_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_right_shift()
         {
             int2x3 a0 = int2x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842);
@@ -1202,7 +1202,7 @@ public static void int2x3_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x3_operator_bitwise_not()
         {
             int2x3 a0 = int2x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399);
@@ -1222,7 +1222,7 @@ public static void int2x3_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void int2x3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new int2x3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestInt2x4.gen.cs b/src/Tests/Tests/Shared/TestInt2x4.gen.cs
index f9650035..8700456f 100644
--- a/src/Tests/Tests/Shared/TestInt2x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt2x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt2x4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_zero()
         {
             TestUtils.AreEqual(0, int2x4.zero.c0.x);
@@ -28,7 +28,7 @@ public static void int2x4_zero()
             TestUtils.AreEqual(0, int2x4.zero.c3.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_equal_wide_wide()
         {
             int2x4 a0 = int2x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316);
@@ -52,7 +52,7 @@ public static void int2x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_equal_wide_scalar()
         {
             int2x4 a0 = int2x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849);
@@ -76,7 +76,7 @@ public static void int2x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -100,7 +100,7 @@ public static void int2x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_not_equal_wide_wide()
         {
             int2x4 a0 = int2x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074);
@@ -124,7 +124,7 @@ public static void int2x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_not_equal_wide_scalar()
         {
             int2x4 a0 = int2x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717);
@@ -148,7 +148,7 @@ public static void int2x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -172,7 +172,7 @@ public static void int2x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_less_wide_wide()
         {
             int2x4 a0 = int2x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431);
@@ -196,7 +196,7 @@ public static void int2x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_less_wide_scalar()
         {
             int2x4 a0 = int2x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600);
@@ -220,7 +220,7 @@ public static void int2x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -244,7 +244,7 @@ public static void int2x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_greater_wide_wide()
         {
             int2x4 a0 = int2x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508);
@@ -268,7 +268,7 @@ public static void int2x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_greater_wide_scalar()
         {
             int2x4 a0 = int2x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098);
@@ -292,7 +292,7 @@ public static void int2x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -316,7 +316,7 @@ public static void int2x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_less_equal_wide_wide()
         {
             int2x4 a0 = int2x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725);
@@ -340,7 +340,7 @@ public static void int2x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_less_equal_wide_scalar()
         {
             int2x4 a0 = int2x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307);
@@ -364,7 +364,7 @@ public static void int2x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -388,7 +388,7 @@ public static void int2x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_greater_equal_wide_wide()
         {
             int2x4 a0 = int2x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970);
@@ -412,7 +412,7 @@ public static void int2x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_greater_equal_wide_scalar()
         {
             int2x4 a0 = int2x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187);
@@ -436,7 +436,7 @@ public static void int2x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -460,7 +460,7 @@ public static void int2x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_add_wide_wide()
         {
             int2x4 a0 = int2x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062);
@@ -484,7 +484,7 @@ public static void int2x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_add_wide_scalar()
         {
             int2x4 a0 = int2x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017);
@@ -508,7 +508,7 @@ public static void int2x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -532,7 +532,7 @@ public static void int2x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_sub_wide_wide()
         {
             int2x4 a0 = int2x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215);
@@ -556,7 +556,7 @@ public static void int2x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_sub_wide_scalar()
         {
             int2x4 a0 = int2x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511);
@@ -580,7 +580,7 @@ public static void int2x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -604,7 +604,7 @@ public static void int2x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_mul_wide_wide()
         {
             int2x4 a0 = int2x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644);
@@ -628,7 +628,7 @@ public static void int2x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_mul_wide_scalar()
         {
             int2x4 a0 = int2x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514);
@@ -652,7 +652,7 @@ public static void int2x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -676,7 +676,7 @@ public static void int2x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_div_wide_wide()
         {
             int2x4 a0 = int2x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814);
@@ -700,7 +700,7 @@ public static void int2x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_div_wide_scalar()
         {
             int2x4 a0 = int2x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670);
@@ -724,7 +724,7 @@ public static void int2x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -748,7 +748,7 @@ public static void int2x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_mod_wide_wide()
         {
             int2x4 a0 = int2x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004);
@@ -772,7 +772,7 @@ public static void int2x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_mod_wide_scalar()
         {
             int2x4 a0 = int2x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916);
@@ -796,7 +796,7 @@ public static void int2x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -820,7 +820,7 @@ public static void int2x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_plus()
         {
             int2x4 a0 = int2x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785);
@@ -840,7 +840,7 @@ public static void int2x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_neg()
         {
             int2x4 a0 = int2x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961);
@@ -860,7 +860,7 @@ public static void int2x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_prefix_inc()
         {
             int2x4 a0 = int2x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162);
@@ -880,7 +880,7 @@ public static void int2x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_postfix_inc()
         {
             int2x4 a0 = int2x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244);
@@ -900,7 +900,7 @@ public static void int2x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_prefix_dec()
         {
             int2x4 a0 = int2x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664);
@@ -920,7 +920,7 @@ public static void int2x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_postfix_dec()
         {
             int2x4 a0 = int2x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351);
@@ -940,7 +940,7 @@ public static void int2x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_bitwise_and_wide_wide()
         {
             int2x4 a0 = int2x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753);
@@ -964,7 +964,7 @@ public static void int2x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_bitwise_and_wide_scalar()
         {
             int2x4 a0 = int2x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908);
@@ -988,7 +988,7 @@ public static void int2x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1012,7 +1012,7 @@ public static void int2x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_bitwise_or_wide_wide()
         {
             int2x4 a0 = int2x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323);
@@ -1036,7 +1036,7 @@ public static void int2x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_bitwise_or_wide_scalar()
         {
             int2x4 a0 = int2x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350);
@@ -1060,7 +1060,7 @@ public static void int2x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1084,7 +1084,7 @@ public static void int2x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_bitwise_xor_wide_wide()
         {
             int2x4 a0 = int2x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658);
@@ -1108,7 +1108,7 @@ public static void int2x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_bitwise_xor_wide_scalar()
         {
             int2x4 a0 = int2x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783);
@@ -1132,7 +1132,7 @@ public static void int2x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1156,7 +1156,7 @@ public static void int2x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_left_shift()
         {
             int2x4 a0 = int2x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862);
@@ -1180,7 +1180,7 @@ public static void int2x4_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_right_shift()
         {
             int2x4 a0 = int2x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632);
@@ -1204,7 +1204,7 @@ public static void int2x4_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2x4_operator_bitwise_not()
         {
             int2x4 a0 = int2x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135);
@@ -1224,7 +1224,7 @@ public static void int2x4_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void int2x4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new int2x4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestInt3.gen.cs b/src/Tests/Tests/Shared/TestInt3.gen.cs
index 29f8ec66..92b93317 100644
--- a/src/Tests/Tests/Shared/TestInt3.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_zero()
         {
             TestUtils.AreEqual(0, int3.zero.x);
@@ -23,7 +23,7 @@ public static void int3_zero()
             TestUtils.AreEqual(0, int3.zero.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_constructor()
         {
             int3 a = new int3(1, 2, 3);
@@ -32,7 +32,7 @@ public static void int3_constructor()
             TestUtils.AreEqual(3, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_scalar_constructor()
         {
             int3 a = new int3(17);
@@ -41,7 +41,7 @@ public static void int3_scalar_constructor()
             TestUtils.AreEqual(17, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_static_constructor()
         {
             int3 a = int3(1, 2, 3);
@@ -50,7 +50,7 @@ public static void int3_static_constructor()
             TestUtils.AreEqual(3, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_static_scalar_constructor()
         {
             int3 a = int3(17);
@@ -59,7 +59,7 @@ public static void int3_static_scalar_constructor()
             TestUtils.AreEqual(17, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_equal_wide_wide()
         {
             int3 a0 = int3(2105871082, 35218899, 1550755093);
@@ -83,7 +83,7 @@ public static void int3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_equal_wide_scalar()
         {
             int3 a0 = int3(437822262, 2020661134, 541786900);
@@ -107,7 +107,7 @@ public static void int3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -131,7 +131,7 @@ public static void int3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_not_equal_wide_wide()
         {
             int3 a0 = int3(1977284100, 1293292704, 1547283851);
@@ -155,7 +155,7 @@ public static void int3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_not_equal_wide_scalar()
         {
             int3 a0 = int3(1038269360, 1427812625, 103361237);
@@ -179,7 +179,7 @@ public static void int3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -203,7 +203,7 @@ public static void int3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_less_wide_wide()
         {
             int3 a0 = int3(1486550609, 1779244308, 1602148045);
@@ -227,7 +227,7 @@ public static void int3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_less_wide_scalar()
         {
             int3 a0 = int3(796797557, 670113454, 933579492);
@@ -251,7 +251,7 @@ public static void int3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -275,7 +275,7 @@ public static void int3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_greater_wide_wide()
         {
             int3 a0 = int3(2087717754, 1725569452, 1298066182);
@@ -299,7 +299,7 @@ public static void int3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_greater_wide_scalar()
         {
             int3 a0 = int3(1208626274, 239697208, 1979453345);
@@ -323,7 +323,7 @@ public static void int3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -347,7 +347,7 @@ public static void int3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_less_equal_wide_wide()
         {
             int3 a0 = int3(154092149, 1515170149, 1083970332);
@@ -371,7 +371,7 @@ public static void int3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_less_equal_wide_scalar()
         {
             int3 a0 = int3(1479531977, 1427983411, 415250630);
@@ -395,7 +395,7 @@ public static void int3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -419,7 +419,7 @@ public static void int3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_greater_equal_wide_wide()
         {
             int3 a0 = int3(8538378, 2131749726, 265427108);
@@ -443,7 +443,7 @@ public static void int3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_greater_equal_wide_scalar()
         {
             int3 a0 = int3(2049236663, 182691143, 634973382);
@@ -467,7 +467,7 @@ public static void int3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -491,7 +491,7 @@ public static void int3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_add_wide_wide()
         {
             int3 a0 = int3(2135171378, 21433296, 1954723494);
@@ -515,7 +515,7 @@ public static void int3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_add_wide_scalar()
         {
             int3 a0 = int3(665815972, 1783729250, 1591678394);
@@ -539,7 +539,7 @@ public static void int3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -563,7 +563,7 @@ public static void int3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_sub_wide_wide()
         {
             int3 a0 = int3(1410318491, 1097280168, 1827039044);
@@ -587,7 +587,7 @@ public static void int3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_sub_wide_scalar()
         {
             int3 a0 = int3(1508669340, 1594795463, 266707545);
@@ -611,7 +611,7 @@ public static void int3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -635,7 +635,7 @@ public static void int3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_mul_wide_wide()
         {
             int3 a0 = int3(61417577, 219585476, 1362520891);
@@ -659,7 +659,7 @@ public static void int3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_mul_wide_scalar()
         {
             int3 a0 = int3(871746615, 492532311, 570557670);
@@ -683,7 +683,7 @@ public static void int3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -707,7 +707,7 @@ public static void int3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_div_wide_wide()
         {
             int3 a0 = int3(333171510, 858154903, 1181365836);
@@ -731,7 +731,7 @@ public static void int3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_div_wide_scalar()
         {
             int3 a0 = int3(1433072926, 1073958635, 1195142312);
@@ -755,7 +755,7 @@ public static void int3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -779,7 +779,7 @@ public static void int3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_mod_wide_wide()
         {
             int3 a0 = int3(258342924, 1454754891, 723352342);
@@ -803,7 +803,7 @@ public static void int3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_mod_wide_scalar()
         {
             int3 a0 = int3(560988938, 629524514, 767711194);
@@ -827,7 +827,7 @@ public static void int3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -851,7 +851,7 @@ public static void int3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_plus()
         {
             int3 a0 = int3(195392567, 222719748, 1002351013);
@@ -871,7 +871,7 @@ public static void int3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_neg()
         {
             int3 a0 = int3(1385088677, 94114564, 1350664872);
@@ -891,7 +891,7 @@ public static void int3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_prefix_inc()
         {
             int3 a0 = int3(780471723, 954741756, 272723451);
@@ -911,7 +911,7 @@ public static void int3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_postfix_inc()
         {
             int3 a0 = int3(241865086, 2145821641, 1596166022);
@@ -931,7 +931,7 @@ public static void int3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_prefix_dec()
         {
             int3 a0 = int3(1331961415, 1612382200, 1401591249);
@@ -951,7 +951,7 @@ public static void int3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_postfix_dec()
         {
             int3 a0 = int3(1870005937, 1708534798, 704493460);
@@ -971,7 +971,7 @@ public static void int3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_bitwise_and_wide_wide()
         {
             int3 a0 = int3(1055241304, 859321394, 1088358961);
@@ -995,7 +995,7 @@ public static void int3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_bitwise_and_wide_scalar()
         {
             int3 a0 = int3(1513158868, 284695609, 734595037);
@@ -1019,7 +1019,7 @@ public static void int3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1043,7 +1043,7 @@ public static void int3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_bitwise_or_wide_wide()
         {
             int3 a0 = int3(1920951869, 1750772852, 1420019191);
@@ -1067,7 +1067,7 @@ public static void int3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_bitwise_or_wide_scalar()
         {
             int3 a0 = int3(1295304853, 1307252624, 350194630);
@@ -1091,7 +1091,7 @@ public static void int3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1115,7 +1115,7 @@ public static void int3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_bitwise_xor_wide_wide()
         {
             int3 a0 = int3(1843655608, 362425681, 640805534);
@@ -1139,7 +1139,7 @@ public static void int3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_bitwise_xor_wide_scalar()
         {
             int3 a0 = int3(169345668, 176087064, 2084362901);
@@ -1163,7 +1163,7 @@ public static void int3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1187,7 +1187,7 @@ public static void int3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_left_shift()
         {
             int3 a0 = int3(1129100049, 829482269, 1571297368);
@@ -1211,7 +1211,7 @@ public static void int3_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_right_shift()
         {
             int3 a0 = int3(809126085, 908563670, 763568837);
@@ -1235,7 +1235,7 @@ public static void int3_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_operator_bitwise_not()
         {
             int3 a0 = int3(111796841, 603562399, 745091931);
@@ -1255,7 +1255,7 @@ public static void int3_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_shuffle_result_1()
         {
             int3 a = int3(0, 1, 2);
@@ -1269,7 +1269,7 @@ public static void int3_shuffle_result_1()
             TestUtils.AreEqual((5), shuffle(a, b, ShuffleComponent.RightZ));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_shuffle_result_2()
         {
             int3 a = int3(0, 1, 2);
@@ -1293,7 +1293,7 @@ public static void int3_shuffle_result_2()
             TestUtils.AreEqual(int2(1, 2), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_shuffle_result_3()
         {
             int3 a = int3(0, 1, 2);
@@ -1317,7 +1317,7 @@ public static void int3_shuffle_result_3()
             TestUtils.AreEqual(int3(4, 0, 5), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_shuffle_result_4()
         {
             int3 a = int3(0, 1, 2);
@@ -1341,7 +1341,7 @@ public static void int3_shuffle_result_4()
             TestUtils.AreEqual(int4(2, 5, 0, 4), shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightY));
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void int3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new int3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestInt3x2.gen.cs b/src/Tests/Tests/Shared/TestInt3x2.gen.cs
index 11b9edb4..769f2d00 100644
--- a/src/Tests/Tests/Shared/TestInt3x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt3x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt3x2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_zero()
         {
             TestUtils.AreEqual(0, int3x2.zero.c0.x);
@@ -26,7 +26,7 @@ public static void int3x2_zero()
             TestUtils.AreEqual(0, int3x2.zero.c1.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_equal_wide_wide()
         {
             int3x2 a0 = int3x2(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098);
@@ -50,7 +50,7 @@ public static void int3x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_equal_wide_scalar()
         {
             int3x2 a0 = int3x2(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405);
@@ -74,7 +74,7 @@ public static void int3x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -98,7 +98,7 @@ public static void int3x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_not_equal_wide_wide()
         {
             int3x2 a0 = int3x2(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892);
@@ -122,7 +122,7 @@ public static void int3x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_not_equal_wide_scalar()
         {
             int3x2 a0 = int3x2(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802);
@@ -146,7 +146,7 @@ public static void int3x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -170,7 +170,7 @@ public static void int3x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_less_wide_wide()
         {
             int3x2 a0 = int3x2(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342);
@@ -194,7 +194,7 @@ public static void int3x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_less_wide_scalar()
         {
             int3x2 a0 = int3x2(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673);
@@ -218,7 +218,7 @@ public static void int3x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -242,7 +242,7 @@ public static void int3x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_greater_wide_wide()
         {
             int3x2 a0 = int3x2(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491);
@@ -266,7 +266,7 @@ public static void int3x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_greater_wide_scalar()
         {
             int3x2 a0 = int3x2(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635);
@@ -290,7 +290,7 @@ public static void int3x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -314,7 +314,7 @@ public static void int3x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_less_equal_wide_wide()
         {
             int3x2 a0 = int3x2(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627);
@@ -338,7 +338,7 @@ public static void int3x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_less_equal_wide_scalar()
         {
             int3x2 a0 = int3x2(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632);
@@ -362,7 +362,7 @@ public static void int3x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -386,7 +386,7 @@ public static void int3x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_greater_equal_wide_wide()
         {
             int3x2 a0 = int3x2(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564);
@@ -410,7 +410,7 @@ public static void int3x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_greater_equal_wide_scalar()
         {
             int3x2 a0 = int3x2(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469);
@@ -434,7 +434,7 @@ public static void int3x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -458,7 +458,7 @@ public static void int3x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_add_wide_wide()
         {
             int3x2 a0 = int3x2(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995);
@@ -482,7 +482,7 @@ public static void int3x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_add_wide_scalar()
         {
             int3x2 a0 = int3x2(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732);
@@ -506,7 +506,7 @@ public static void int3x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -530,7 +530,7 @@ public static void int3x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_sub_wide_wide()
         {
             int3x2 a0 = int3x2(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868);
@@ -554,7 +554,7 @@ public static void int3x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_sub_wide_scalar()
         {
             int3x2 a0 = int3x2(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328);
@@ -578,7 +578,7 @@ public static void int3x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -602,7 +602,7 @@ public static void int3x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_mul_wide_wide()
         {
             int3x2 a0 = int3x2(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871);
@@ -626,7 +626,7 @@ public static void int3x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_mul_wide_scalar()
         {
             int3x2 a0 = int3x2(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563);
@@ -650,7 +650,7 @@ public static void int3x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -674,7 +674,7 @@ public static void int3x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_div_wide_wide()
         {
             int3x2 a0 = int3x2(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420);
@@ -698,7 +698,7 @@ public static void int3x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_div_wide_scalar()
         {
             int3x2 a0 = int3x2(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346);
@@ -722,7 +722,7 @@ public static void int3x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -746,7 +746,7 @@ public static void int3x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_mod_wide_wide()
         {
             int3x2 a0 = int3x2(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627);
@@ -770,7 +770,7 @@ public static void int3x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_mod_wide_scalar()
         {
             int3x2 a0 = int3x2(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846);
@@ -794,7 +794,7 @@ public static void int3x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -818,7 +818,7 @@ public static void int3x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_plus()
         {
             int3x2 a0 = int3x2(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277);
@@ -838,7 +838,7 @@ public static void int3x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_neg()
         {
             int3x2 a0 = int3x2(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493);
@@ -858,7 +858,7 @@ public static void int3x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_prefix_inc()
         {
             int3x2 a0 = int3x2(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550);
@@ -878,7 +878,7 @@ public static void int3x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_postfix_inc()
         {
             int3x2 a0 = int3x2(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229);
@@ -898,7 +898,7 @@ public static void int3x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_prefix_dec()
         {
             int3x2 a0 = int3x2(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159);
@@ -918,7 +918,7 @@ public static void int3x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_postfix_dec()
         {
             int3x2 a0 = int3x2(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869);
@@ -938,7 +938,7 @@ public static void int3x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_bitwise_and_wide_wide()
         {
             int3x2 a0 = int3x2(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515);
@@ -962,7 +962,7 @@ public static void int3x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_bitwise_and_wide_scalar()
         {
             int3x2 a0 = int3x2(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838);
@@ -986,7 +986,7 @@ public static void int3x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1010,7 +1010,7 @@ public static void int3x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_bitwise_or_wide_wide()
         {
             int3x2 a0 = int3x2(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930);
@@ -1034,7 +1034,7 @@ public static void int3x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_bitwise_or_wide_scalar()
         {
             int3x2 a0 = int3x2(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467);
@@ -1058,7 +1058,7 @@ public static void int3x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1082,7 +1082,7 @@ public static void int3x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_bitwise_xor_wide_wide()
         {
             int3x2 a0 = int3x2(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850);
@@ -1106,7 +1106,7 @@ public static void int3x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_bitwise_xor_wide_scalar()
         {
             int3x2 a0 = int3x2(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661);
@@ -1130,7 +1130,7 @@ public static void int3x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1154,7 +1154,7 @@ public static void int3x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_left_shift()
         {
             int3x2 a0 = int3x2(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593);
@@ -1178,7 +1178,7 @@ public static void int3x2_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_right_shift()
         {
             int3x2 a0 = int3x2(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842);
@@ -1202,7 +1202,7 @@ public static void int3x2_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x2_operator_bitwise_not()
         {
             int3x2 a0 = int3x2(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399);
@@ -1222,7 +1222,7 @@ public static void int3x2_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void int3x2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new int3x2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestInt3x3.gen.cs b/src/Tests/Tests/Shared/TestInt3x3.gen.cs
index e5b804e0..c2a99c4f 100644
--- a/src/Tests/Tests/Shared/TestInt3x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt3x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt3x3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_zero()
         {
             TestUtils.AreEqual(0, int3x3.zero.c0.x);
@@ -29,7 +29,7 @@ public static void int3x3_zero()
             TestUtils.AreEqual(0, int3x3.zero.c2.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_identity()
         {
             TestUtils.AreEqual(1, int3x3.identity.c0.x);
@@ -43,7 +43,7 @@ public static void int3x3_identity()
             TestUtils.AreEqual(1, int3x3.identity.c2.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_equal_wide_wide()
         {
             int3x3 a0 = int3x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367);
@@ -67,7 +67,7 @@ public static void int3x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_equal_wide_scalar()
         {
             int3x3 a0 = int3x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998);
@@ -91,7 +91,7 @@ public static void int3x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -115,7 +115,7 @@ public static void int3x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_not_equal_wide_wide()
         {
             int3x3 a0 = int3x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678);
@@ -139,7 +139,7 @@ public static void int3x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_not_equal_wide_scalar()
         {
             int3x3 a0 = int3x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423);
@@ -163,7 +163,7 @@ public static void int3x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -187,7 +187,7 @@ public static void int3x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_less_wide_wide()
         {
             int3x3 a0 = int3x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312);
@@ -211,7 +211,7 @@ public static void int3x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_less_wide_scalar()
         {
             int3x3 a0 = int3x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597);
@@ -235,7 +235,7 @@ public static void int3x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -259,7 +259,7 @@ public static void int3x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_greater_wide_wide()
         {
             int3x3 a0 = int3x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133);
@@ -283,7 +283,7 @@ public static void int3x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_greater_wide_scalar()
         {
             int3x3 a0 = int3x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855);
@@ -307,7 +307,7 @@ public static void int3x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -331,7 +331,7 @@ public static void int3x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_less_equal_wide_wide()
         {
             int3x3 a0 = int3x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541);
@@ -355,7 +355,7 @@ public static void int3x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_less_equal_wide_scalar()
         {
             int3x3 a0 = int3x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375);
@@ -379,7 +379,7 @@ public static void int3x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -403,7 +403,7 @@ public static void int3x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_greater_equal_wide_wide()
         {
             int3x3 a0 = int3x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826);
@@ -427,7 +427,7 @@ public static void int3x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_greater_equal_wide_scalar()
         {
             int3x3 a0 = int3x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669);
@@ -451,7 +451,7 @@ public static void int3x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -475,7 +475,7 @@ public static void int3x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_add_wide_wide()
         {
             int3x3 a0 = int3x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600);
@@ -499,7 +499,7 @@ public static void int3x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_add_wide_scalar()
         {
             int3x3 a0 = int3x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008);
@@ -523,7 +523,7 @@ public static void int3x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -547,7 +547,7 @@ public static void int3x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_sub_wide_wide()
         {
             int3x3 a0 = int3x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315);
@@ -571,7 +571,7 @@ public static void int3x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_sub_wide_scalar()
         {
             int3x3 a0 = int3x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113);
@@ -595,7 +595,7 @@ public static void int3x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -619,7 +619,7 @@ public static void int3x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_mul_wide_wide()
         {
             int3x3 a0 = int3x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583);
@@ -643,7 +643,7 @@ public static void int3x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_mul_wide_scalar()
         {
             int3x3 a0 = int3x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059);
@@ -667,7 +667,7 @@ public static void int3x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -691,7 +691,7 @@ public static void int3x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_div_wide_wide()
         {
             int3x3 a0 = int3x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195);
@@ -715,7 +715,7 @@ public static void int3x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_div_wide_scalar()
         {
             int3x3 a0 = int3x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136);
@@ -739,7 +739,7 @@ public static void int3x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -763,7 +763,7 @@ public static void int3x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_mod_wide_wide()
         {
             int3x3 a0 = int3x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101);
@@ -787,7 +787,7 @@ public static void int3x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_mod_wide_scalar()
         {
             int3x3 a0 = int3x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144);
@@ -811,7 +811,7 @@ public static void int3x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -835,7 +835,7 @@ public static void int3x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_plus()
         {
             int3x3 a0 = int3x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671);
@@ -855,7 +855,7 @@ public static void int3x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_neg()
         {
             int3x3 a0 = int3x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525);
@@ -875,7 +875,7 @@ public static void int3x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_prefix_inc()
         {
             int3x3 a0 = int3x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994);
@@ -895,7 +895,7 @@ public static void int3x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_postfix_inc()
         {
             int3x3 a0 = int3x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247);
@@ -915,7 +915,7 @@ public static void int3x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_prefix_dec()
         {
             int3x3 a0 = int3x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745);
@@ -935,7 +935,7 @@ public static void int3x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_postfix_dec()
         {
             int3x3 a0 = int3x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889);
@@ -955,7 +955,7 @@ public static void int3x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_bitwise_and_wide_wide()
         {
             int3x3 a0 = int3x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656);
@@ -979,7 +979,7 @@ public static void int3x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_bitwise_and_wide_scalar()
         {
             int3x3 a0 = int3x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263);
@@ -1003,7 +1003,7 @@ public static void int3x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1027,7 +1027,7 @@ public static void int3x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_bitwise_or_wide_wide()
         {
             int3x3 a0 = int3x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869);
@@ -1051,7 +1051,7 @@ public static void int3x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_bitwise_or_wide_scalar()
         {
             int3x3 a0 = int3x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307);
@@ -1075,7 +1075,7 @@ public static void int3x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1099,7 +1099,7 @@ public static void int3x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_bitwise_xor_wide_wide()
         {
             int3x3 a0 = int3x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251);
@@ -1123,7 +1123,7 @@ public static void int3x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_bitwise_xor_wide_scalar()
         {
             int3x3 a0 = int3x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873);
@@ -1147,7 +1147,7 @@ public static void int3x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1171,7 +1171,7 @@ public static void int3x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_left_shift()
         {
             int3x3 a0 = int3x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727);
@@ -1195,7 +1195,7 @@ public static void int3x3_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_right_shift()
         {
             int3x3 a0 = int3x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393);
@@ -1219,7 +1219,7 @@ public static void int3x3_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x3_operator_bitwise_not()
         {
             int3x3 a0 = int3x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628);
@@ -1239,7 +1239,7 @@ public static void int3x3_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void int3x3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new int3x3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestInt3x4.gen.cs b/src/Tests/Tests/Shared/TestInt3x4.gen.cs
index 254a797c..449377a8 100644
--- a/src/Tests/Tests/Shared/TestInt3x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt3x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt3x4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_zero()
         {
             TestUtils.AreEqual(0, int3x4.zero.c0.x);
@@ -32,7 +32,7 @@ public static void int3x4_zero()
             TestUtils.AreEqual(0, int3x4.zero.c3.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_equal_wide_wide()
         {
             int3x4 a0 = int3x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837);
@@ -56,7 +56,7 @@ public static void int3x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_equal_wide_scalar()
         {
             int3x4 a0 = int3x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137);
@@ -80,7 +80,7 @@ public static void int3x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -104,7 +104,7 @@ public static void int3x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_not_equal_wide_wide()
         {
             int3x4 a0 = int3x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545);
@@ -128,7 +128,7 @@ public static void int3x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_not_equal_wide_scalar()
         {
             int3x4 a0 = int3x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494);
@@ -152,7 +152,7 @@ public static void int3x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -176,7 +176,7 @@ public static void int3x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_less_wide_wide()
         {
             int3x4 a0 = int3x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069);
@@ -200,7 +200,7 @@ public static void int3x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_less_wide_scalar()
         {
             int3x4 a0 = int3x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417);
@@ -224,7 +224,7 @@ public static void int3x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -248,7 +248,7 @@ public static void int3x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_greater_wide_wide()
         {
             int3x4 a0 = int3x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903);
@@ -272,7 +272,7 @@ public static void int3x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_greater_wide_scalar()
         {
             int3x4 a0 = int3x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960);
@@ -296,7 +296,7 @@ public static void int3x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -320,7 +320,7 @@ public static void int3x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_less_equal_wide_wide()
         {
             int3x4 a0 = int3x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946);
@@ -344,7 +344,7 @@ public static void int3x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_less_equal_wide_scalar()
         {
             int3x4 a0 = int3x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501);
@@ -368,7 +368,7 @@ public static void int3x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -392,7 +392,7 @@ public static void int3x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_greater_equal_wide_wide()
         {
             int3x4 a0 = int3x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752);
@@ -416,7 +416,7 @@ public static void int3x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_greater_equal_wide_scalar()
         {
             int3x4 a0 = int3x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390);
@@ -440,7 +440,7 @@ public static void int3x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -464,7 +464,7 @@ public static void int3x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_add_wide_wide()
         {
             int3x4 a0 = int3x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462);
@@ -488,7 +488,7 @@ public static void int3x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_add_wide_scalar()
         {
             int3x4 a0 = int3x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642);
@@ -512,7 +512,7 @@ public static void int3x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -536,7 +536,7 @@ public static void int3x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_sub_wide_wide()
         {
             int3x4 a0 = int3x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285);
@@ -560,7 +560,7 @@ public static void int3x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_sub_wide_scalar()
         {
             int3x4 a0 = int3x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508);
@@ -584,7 +584,7 @@ public static void int3x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -608,7 +608,7 @@ public static void int3x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_mul_wide_wide()
         {
             int3x4 a0 = int3x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842);
@@ -632,7 +632,7 @@ public static void int3x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_mul_wide_scalar()
         {
             int3x4 a0 = int3x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203);
@@ -656,7 +656,7 @@ public static void int3x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -680,7 +680,7 @@ public static void int3x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_div_wide_wide()
         {
             int3x4 a0 = int3x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736);
@@ -704,7 +704,7 @@ public static void int3x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_div_wide_scalar()
         {
             int3x4 a0 = int3x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377);
@@ -728,7 +728,7 @@ public static void int3x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -752,7 +752,7 @@ public static void int3x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_mod_wide_wide()
         {
             int3x4 a0 = int3x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293);
@@ -776,7 +776,7 @@ public static void int3x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_mod_wide_scalar()
         {
             int3x4 a0 = int3x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785);
@@ -800,7 +800,7 @@ public static void int3x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -824,7 +824,7 @@ public static void int3x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_plus()
         {
             int3x4 a0 = int3x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223);
@@ -844,7 +844,7 @@ public static void int3x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_neg()
         {
             int3x4 a0 = int3x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822);
@@ -864,7 +864,7 @@ public static void int3x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_prefix_inc()
         {
             int3x4 a0 = int3x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735);
@@ -884,7 +884,7 @@ public static void int3x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_postfix_inc()
         {
             int3x4 a0 = int3x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446);
@@ -904,7 +904,7 @@ public static void int3x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_prefix_dec()
         {
             int3x4 a0 = int3x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220);
@@ -924,7 +924,7 @@ public static void int3x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_postfix_dec()
         {
             int3x4 a0 = int3x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851);
@@ -944,7 +944,7 @@ public static void int3x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_bitwise_and_wide_wide()
         {
             int3x4 a0 = int3x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302);
@@ -968,7 +968,7 @@ public static void int3x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_bitwise_and_wide_scalar()
         {
             int3x4 a0 = int3x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546);
@@ -992,7 +992,7 @@ public static void int3x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1016,7 +1016,7 @@ public static void int3x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_bitwise_or_wide_wide()
         {
             int3x4 a0 = int3x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227);
@@ -1040,7 +1040,7 @@ public static void int3x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_bitwise_or_wide_scalar()
         {
             int3x4 a0 = int3x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676);
@@ -1064,7 +1064,7 @@ public static void int3x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1088,7 +1088,7 @@ public static void int3x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_bitwise_xor_wide_wide()
         {
             int3x4 a0 = int3x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919);
@@ -1112,7 +1112,7 @@ public static void int3x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_bitwise_xor_wide_scalar()
         {
             int3x4 a0 = int3x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786);
@@ -1136,7 +1136,7 @@ public static void int3x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1160,7 +1160,7 @@ public static void int3x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_left_shift()
         {
             int3x4 a0 = int3x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902);
@@ -1184,7 +1184,7 @@ public static void int3x4_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_right_shift()
         {
             int3x4 a0 = int3x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878);
@@ -1208,7 +1208,7 @@ public static void int3x4_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3x4_operator_bitwise_not()
         {
             int3x4 a0 = int3x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785);
@@ -1228,7 +1228,7 @@ public static void int3x4_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void int3x4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new int3x4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestInt4.gen.cs b/src/Tests/Tests/Shared/TestInt4.gen.cs
index 065bb609..5aaff365 100644
--- a/src/Tests/Tests/Shared/TestInt4.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_zero()
         {
             TestUtils.AreEqual(0, int4.zero.x);
@@ -24,7 +24,7 @@ public static void int4_zero()
             TestUtils.AreEqual(0, int4.zero.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_constructor()
         {
             int4 a = new int4(1, 2, 3, 4);
@@ -34,7 +34,7 @@ public static void int4_constructor()
             TestUtils.AreEqual(4, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_scalar_constructor()
         {
             int4 a = new int4(17);
@@ -44,7 +44,7 @@ public static void int4_scalar_constructor()
             TestUtils.AreEqual(17, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_static_constructor()
         {
             int4 a = int4(1, 2, 3, 4);
@@ -54,7 +54,7 @@ public static void int4_static_constructor()
             TestUtils.AreEqual(4, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_static_scalar_constructor()
         {
             int4 a = int4(17);
@@ -64,7 +64,7 @@ public static void int4_static_scalar_constructor()
             TestUtils.AreEqual(17, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_equal_wide_wide()
         {
             int4 a0 = int4(2105871082, 35218899, 1550755093, 764676020);
@@ -88,7 +88,7 @@ public static void int4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_equal_wide_scalar()
         {
             int4 a0 = int4(437822262, 2020661134, 541786900, 853113810);
@@ -112,7 +112,7 @@ public static void int4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -136,7 +136,7 @@ public static void int4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_not_equal_wide_wide()
         {
             int4 a0 = int4(1977284100, 1293292704, 1547283851, 422428953);
@@ -160,7 +160,7 @@ public static void int4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_not_equal_wide_scalar()
         {
             int4 a0 = int4(1038269360, 1427812625, 103361237, 1347017023);
@@ -184,7 +184,7 @@ public static void int4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -208,7 +208,7 @@ public static void int4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_less_wide_wide()
         {
             int4 a0 = int4(1486550609, 1779244308, 1602148045, 1614085440);
@@ -232,7 +232,7 @@ public static void int4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_less_wide_scalar()
         {
             int4 a0 = int4(796797557, 670113454, 933579492, 278884514);
@@ -256,7 +256,7 @@ public static void int4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -280,7 +280,7 @@ public static void int4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_greater_wide_wide()
         {
             int4 a0 = int4(2087717754, 1725569452, 1298066182, 1693943616);
@@ -304,7 +304,7 @@ public static void int4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_greater_wide_scalar()
         {
             int4 a0 = int4(1208626274, 239697208, 1979453345, 1253474001);
@@ -328,7 +328,7 @@ public static void int4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -352,7 +352,7 @@ public static void int4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_less_equal_wide_wide()
         {
             int4 a0 = int4(154092149, 1515170149, 1083970332, 785807178);
@@ -376,7 +376,7 @@ public static void int4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_less_equal_wide_scalar()
         {
             int4 a0 = int4(1479531977, 1427983411, 415250630, 1245345407);
@@ -400,7 +400,7 @@ public static void int4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -424,7 +424,7 @@ public static void int4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_greater_equal_wide_wide()
         {
             int4 a0 = int4(8538378, 2131749726, 265427108, 523609761);
@@ -448,7 +448,7 @@ public static void int4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_greater_equal_wide_scalar()
         {
             int4 a0 = int4(2049236663, 182691143, 634973382, 1197012109);
@@ -472,7 +472,7 @@ public static void int4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -496,7 +496,7 @@ public static void int4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_add_wide_wide()
         {
             int4 a0 = int4(2135171378, 21433296, 1954723494, 683604307);
@@ -520,7 +520,7 @@ public static void int4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_add_wide_scalar()
         {
             int4 a0 = int4(665815972, 1783729250, 1591678394, 1284528538);
@@ -544,7 +544,7 @@ public static void int4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -568,7 +568,7 @@ public static void int4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_sub_wide_wide()
         {
             int4 a0 = int4(1410318491, 1097280168, 1827039044, 28881338);
@@ -592,7 +592,7 @@ public static void int4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_sub_wide_scalar()
         {
             int4 a0 = int4(1508669340, 1594795463, 266707545, 643102647);
@@ -616,7 +616,7 @@ public static void int4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -640,7 +640,7 @@ public static void int4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_mul_wide_wide()
         {
             int4 a0 = int4(61417577, 219585476, 1362520891, 1511084277);
@@ -664,7 +664,7 @@ public static void int4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_mul_wide_scalar()
         {
             int4 a0 = int4(871746615, 492532311, 570557670, 2142306629);
@@ -688,7 +688,7 @@ public static void int4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -712,7 +712,7 @@ public static void int4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_div_wide_wide()
         {
             int4 a0 = int4(333171510, 858154903, 1181365836, 671357749);
@@ -736,7 +736,7 @@ public static void int4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_div_wide_scalar()
         {
             int4 a0 = int4(1433072926, 1073958635, 1195142312, 536596719);
@@ -760,7 +760,7 @@ public static void int4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -784,7 +784,7 @@ public static void int4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_mod_wide_wide()
         {
             int4 a0 = int4(258342924, 1454754891, 723352342, 1981431473);
@@ -808,7 +808,7 @@ public static void int4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_mod_wide_scalar()
         {
             int4 a0 = int4(560988938, 629524514, 767711194, 434281967);
@@ -832,7 +832,7 @@ public static void int4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -856,7 +856,7 @@ public static void int4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_plus()
         {
             int4 a0 = int4(195392567, 222719748, 1002351013, 1570765263);
@@ -876,7 +876,7 @@ public static void int4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_neg()
         {
             int4 a0 = int4(1385088677, 94114564, 1350664872, 1458616659);
@@ -896,7 +896,7 @@ public static void int4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_prefix_inc()
         {
             int4 a0 = int4(780471723, 954741756, 272723451, 2142862245);
@@ -916,7 +916,7 @@ public static void int4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_postfix_inc()
         {
             int4 a0 = int4(241865086, 2145821641, 1596166022, 803592338);
@@ -936,7 +936,7 @@ public static void int4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_prefix_dec()
         {
             int4 a0 = int4(1331961415, 1612382200, 1401591249, 2042075388);
@@ -956,7 +956,7 @@ public static void int4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_postfix_dec()
         {
             int4 a0 = int4(1870005937, 1708534798, 704493460, 462940703);
@@ -976,7 +976,7 @@ public static void int4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_bitwise_and_wide_wide()
         {
             int4 a0 = int4(1055241304, 859321394, 1088358961, 2090949513);
@@ -1000,7 +1000,7 @@ public static void int4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_bitwise_and_wide_scalar()
         {
             int4 a0 = int4(1513158868, 284695609, 734595037, 1566510707);
@@ -1024,7 +1024,7 @@ public static void int4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1048,7 +1048,7 @@ public static void int4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_bitwise_or_wide_wide()
         {
             int4 a0 = int4(1920951869, 1750772852, 1420019191, 732977093);
@@ -1072,7 +1072,7 @@ public static void int4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_bitwise_or_wide_scalar()
         {
             int4 a0 = int4(1295304853, 1307252624, 350194630, 1128063578);
@@ -1096,7 +1096,7 @@ public static void int4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1120,7 +1120,7 @@ public static void int4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_bitwise_xor_wide_wide()
         {
             int4 a0 = int4(1843655608, 362425681, 640805534, 1342040268);
@@ -1144,7 +1144,7 @@ public static void int4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_bitwise_xor_wide_scalar()
         {
             int4 a0 = int4(169345668, 176087064, 2084362901, 1663924004);
@@ -1168,7 +1168,7 @@ public static void int4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1192,7 +1192,7 @@ public static void int4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_left_shift()
         {
             int4 a0 = int4(1129100049, 829482269, 1571297368, 443753193);
@@ -1216,7 +1216,7 @@ public static void int4_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_right_shift()
         {
             int4 a0 = int4(809126085, 908563670, 763568837, 1986717290);
@@ -1240,7 +1240,7 @@ public static void int4_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_operator_bitwise_not()
         {
             int4 a0 = int4(111796841, 603562399, 745091931, 853183268);
@@ -1260,7 +1260,7 @@ public static void int4_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_shuffle_result_1()
         {
             int4 a = int4(0, 1, 2, 3);
@@ -1276,7 +1276,7 @@ public static void int4_shuffle_result_1()
             TestUtils.AreEqual((7), shuffle(a, b, ShuffleComponent.RightW));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_shuffle_result_2()
         {
             int4 a = int4(0, 1, 2, 3);
@@ -1300,7 +1300,7 @@ public static void int4_shuffle_result_2()
             TestUtils.AreEqual(int2(1, 3), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_shuffle_result_3()
         {
             int4 a = int4(0, 1, 2, 3);
@@ -1324,7 +1324,7 @@ public static void int4_shuffle_result_3()
             TestUtils.AreEqual(int3(5, 1, 7), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_shuffle_result_4()
         {
             int4 a = int4(0, 1, 2, 3);
@@ -1348,7 +1348,7 @@ public static void int4_shuffle_result_4()
             TestUtils.AreEqual(int4(3, 7, 1, 5), shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.LeftY, ShuffleComponent.RightY));
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void int4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new int4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestInt4x2.gen.cs b/src/Tests/Tests/Shared/TestInt4x2.gen.cs
index 564c7aa7..c4528cd7 100644
--- a/src/Tests/Tests/Shared/TestInt4x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt4x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt4x2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_zero()
         {
             TestUtils.AreEqual(0, int4x2.zero.c0.x);
@@ -28,7 +28,7 @@ public static void int4x2_zero()
             TestUtils.AreEqual(0, int4x2.zero.c1.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_equal_wide_wide()
         {
             int4x2 a0 = int4x2(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316);
@@ -52,7 +52,7 @@ public static void int4x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_equal_wide_scalar()
         {
             int4x2 a0 = int4x2(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849);
@@ -76,7 +76,7 @@ public static void int4x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -100,7 +100,7 @@ public static void int4x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_not_equal_wide_wide()
         {
             int4x2 a0 = int4x2(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074);
@@ -124,7 +124,7 @@ public static void int4x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_not_equal_wide_scalar()
         {
             int4x2 a0 = int4x2(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717);
@@ -148,7 +148,7 @@ public static void int4x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -172,7 +172,7 @@ public static void int4x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_less_wide_wide()
         {
             int4x2 a0 = int4x2(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431);
@@ -196,7 +196,7 @@ public static void int4x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_less_wide_scalar()
         {
             int4x2 a0 = int4x2(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600);
@@ -220,7 +220,7 @@ public static void int4x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -244,7 +244,7 @@ public static void int4x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_greater_wide_wide()
         {
             int4x2 a0 = int4x2(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508);
@@ -268,7 +268,7 @@ public static void int4x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_greater_wide_scalar()
         {
             int4x2 a0 = int4x2(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098);
@@ -292,7 +292,7 @@ public static void int4x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -316,7 +316,7 @@ public static void int4x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_less_equal_wide_wide()
         {
             int4x2 a0 = int4x2(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725);
@@ -340,7 +340,7 @@ public static void int4x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_less_equal_wide_scalar()
         {
             int4x2 a0 = int4x2(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307);
@@ -364,7 +364,7 @@ public static void int4x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -388,7 +388,7 @@ public static void int4x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_greater_equal_wide_wide()
         {
             int4x2 a0 = int4x2(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970);
@@ -412,7 +412,7 @@ public static void int4x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_greater_equal_wide_scalar()
         {
             int4x2 a0 = int4x2(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187);
@@ -436,7 +436,7 @@ public static void int4x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -460,7 +460,7 @@ public static void int4x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_add_wide_wide()
         {
             int4x2 a0 = int4x2(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062);
@@ -484,7 +484,7 @@ public static void int4x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_add_wide_scalar()
         {
             int4x2 a0 = int4x2(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017);
@@ -508,7 +508,7 @@ public static void int4x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -532,7 +532,7 @@ public static void int4x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_sub_wide_wide()
         {
             int4x2 a0 = int4x2(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215);
@@ -556,7 +556,7 @@ public static void int4x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_sub_wide_scalar()
         {
             int4x2 a0 = int4x2(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511);
@@ -580,7 +580,7 @@ public static void int4x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -604,7 +604,7 @@ public static void int4x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_mul_wide_wide()
         {
             int4x2 a0 = int4x2(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644);
@@ -628,7 +628,7 @@ public static void int4x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_mul_wide_scalar()
         {
             int4x2 a0 = int4x2(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514);
@@ -652,7 +652,7 @@ public static void int4x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -676,7 +676,7 @@ public static void int4x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_div_wide_wide()
         {
             int4x2 a0 = int4x2(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814);
@@ -700,7 +700,7 @@ public static void int4x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_div_wide_scalar()
         {
             int4x2 a0 = int4x2(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670);
@@ -724,7 +724,7 @@ public static void int4x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -748,7 +748,7 @@ public static void int4x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_mod_wide_wide()
         {
             int4x2 a0 = int4x2(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004);
@@ -772,7 +772,7 @@ public static void int4x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_mod_wide_scalar()
         {
             int4x2 a0 = int4x2(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916);
@@ -796,7 +796,7 @@ public static void int4x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -820,7 +820,7 @@ public static void int4x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_plus()
         {
             int4x2 a0 = int4x2(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785);
@@ -840,7 +840,7 @@ public static void int4x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_neg()
         {
             int4x2 a0 = int4x2(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961);
@@ -860,7 +860,7 @@ public static void int4x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_prefix_inc()
         {
             int4x2 a0 = int4x2(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162);
@@ -880,7 +880,7 @@ public static void int4x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_postfix_inc()
         {
             int4x2 a0 = int4x2(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244);
@@ -900,7 +900,7 @@ public static void int4x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_prefix_dec()
         {
             int4x2 a0 = int4x2(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664);
@@ -920,7 +920,7 @@ public static void int4x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_postfix_dec()
         {
             int4x2 a0 = int4x2(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351);
@@ -940,7 +940,7 @@ public static void int4x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_bitwise_and_wide_wide()
         {
             int4x2 a0 = int4x2(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753);
@@ -964,7 +964,7 @@ public static void int4x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_bitwise_and_wide_scalar()
         {
             int4x2 a0 = int4x2(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908);
@@ -988,7 +988,7 @@ public static void int4x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1012,7 +1012,7 @@ public static void int4x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_bitwise_or_wide_wide()
         {
             int4x2 a0 = int4x2(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323);
@@ -1036,7 +1036,7 @@ public static void int4x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_bitwise_or_wide_scalar()
         {
             int4x2 a0 = int4x2(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350);
@@ -1060,7 +1060,7 @@ public static void int4x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1084,7 +1084,7 @@ public static void int4x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_bitwise_xor_wide_wide()
         {
             int4x2 a0 = int4x2(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658);
@@ -1108,7 +1108,7 @@ public static void int4x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_bitwise_xor_wide_scalar()
         {
             int4x2 a0 = int4x2(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783);
@@ -1132,7 +1132,7 @@ public static void int4x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1156,7 +1156,7 @@ public static void int4x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_left_shift()
         {
             int4x2 a0 = int4x2(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862);
@@ -1180,7 +1180,7 @@ public static void int4x2_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_right_shift()
         {
             int4x2 a0 = int4x2(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632);
@@ -1204,7 +1204,7 @@ public static void int4x2_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x2_operator_bitwise_not()
         {
             int4x2 a0 = int4x2(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135);
@@ -1224,7 +1224,7 @@ public static void int4x2_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void int4x2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new int4x2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestInt4x3.gen.cs b/src/Tests/Tests/Shared/TestInt4x3.gen.cs
index 6fdd2f07..fec49565 100644
--- a/src/Tests/Tests/Shared/TestInt4x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt4x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt4x3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_zero()
         {
             TestUtils.AreEqual(0, int4x3.zero.c0.x);
@@ -32,7 +32,7 @@ public static void int4x3_zero()
             TestUtils.AreEqual(0, int4x3.zero.c2.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_equal_wide_wide()
         {
             int4x3 a0 = int4x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837);
@@ -56,7 +56,7 @@ public static void int4x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_equal_wide_scalar()
         {
             int4x3 a0 = int4x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137);
@@ -80,7 +80,7 @@ public static void int4x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -104,7 +104,7 @@ public static void int4x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_not_equal_wide_wide()
         {
             int4x3 a0 = int4x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545);
@@ -128,7 +128,7 @@ public static void int4x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_not_equal_wide_scalar()
         {
             int4x3 a0 = int4x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494);
@@ -152,7 +152,7 @@ public static void int4x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -176,7 +176,7 @@ public static void int4x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_less_wide_wide()
         {
             int4x3 a0 = int4x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069);
@@ -200,7 +200,7 @@ public static void int4x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_less_wide_scalar()
         {
             int4x3 a0 = int4x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417);
@@ -224,7 +224,7 @@ public static void int4x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -248,7 +248,7 @@ public static void int4x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_greater_wide_wide()
         {
             int4x3 a0 = int4x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903);
@@ -272,7 +272,7 @@ public static void int4x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_greater_wide_scalar()
         {
             int4x3 a0 = int4x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960);
@@ -296,7 +296,7 @@ public static void int4x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -320,7 +320,7 @@ public static void int4x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_less_equal_wide_wide()
         {
             int4x3 a0 = int4x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946);
@@ -344,7 +344,7 @@ public static void int4x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_less_equal_wide_scalar()
         {
             int4x3 a0 = int4x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501);
@@ -368,7 +368,7 @@ public static void int4x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -392,7 +392,7 @@ public static void int4x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_greater_equal_wide_wide()
         {
             int4x3 a0 = int4x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752);
@@ -416,7 +416,7 @@ public static void int4x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_greater_equal_wide_scalar()
         {
             int4x3 a0 = int4x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390);
@@ -440,7 +440,7 @@ public static void int4x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -464,7 +464,7 @@ public static void int4x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_add_wide_wide()
         {
             int4x3 a0 = int4x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462);
@@ -488,7 +488,7 @@ public static void int4x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_add_wide_scalar()
         {
             int4x3 a0 = int4x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642);
@@ -512,7 +512,7 @@ public static void int4x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -536,7 +536,7 @@ public static void int4x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_sub_wide_wide()
         {
             int4x3 a0 = int4x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285);
@@ -560,7 +560,7 @@ public static void int4x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_sub_wide_scalar()
         {
             int4x3 a0 = int4x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508);
@@ -584,7 +584,7 @@ public static void int4x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -608,7 +608,7 @@ public static void int4x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_mul_wide_wide()
         {
             int4x3 a0 = int4x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842);
@@ -632,7 +632,7 @@ public static void int4x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_mul_wide_scalar()
         {
             int4x3 a0 = int4x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203);
@@ -656,7 +656,7 @@ public static void int4x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -680,7 +680,7 @@ public static void int4x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_div_wide_wide()
         {
             int4x3 a0 = int4x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736);
@@ -704,7 +704,7 @@ public static void int4x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_div_wide_scalar()
         {
             int4x3 a0 = int4x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377);
@@ -728,7 +728,7 @@ public static void int4x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -752,7 +752,7 @@ public static void int4x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_mod_wide_wide()
         {
             int4x3 a0 = int4x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293);
@@ -776,7 +776,7 @@ public static void int4x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_mod_wide_scalar()
         {
             int4x3 a0 = int4x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785);
@@ -800,7 +800,7 @@ public static void int4x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -824,7 +824,7 @@ public static void int4x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_plus()
         {
             int4x3 a0 = int4x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223);
@@ -844,7 +844,7 @@ public static void int4x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_neg()
         {
             int4x3 a0 = int4x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822);
@@ -864,7 +864,7 @@ public static void int4x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_prefix_inc()
         {
             int4x3 a0 = int4x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735);
@@ -884,7 +884,7 @@ public static void int4x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_postfix_inc()
         {
             int4x3 a0 = int4x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446);
@@ -904,7 +904,7 @@ public static void int4x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_prefix_dec()
         {
             int4x3 a0 = int4x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220);
@@ -924,7 +924,7 @@ public static void int4x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_postfix_dec()
         {
             int4x3 a0 = int4x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851);
@@ -944,7 +944,7 @@ public static void int4x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_bitwise_and_wide_wide()
         {
             int4x3 a0 = int4x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302);
@@ -968,7 +968,7 @@ public static void int4x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_bitwise_and_wide_scalar()
         {
             int4x3 a0 = int4x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546);
@@ -992,7 +992,7 @@ public static void int4x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1016,7 +1016,7 @@ public static void int4x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_bitwise_or_wide_wide()
         {
             int4x3 a0 = int4x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227);
@@ -1040,7 +1040,7 @@ public static void int4x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_bitwise_or_wide_scalar()
         {
             int4x3 a0 = int4x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676);
@@ -1064,7 +1064,7 @@ public static void int4x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1088,7 +1088,7 @@ public static void int4x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_bitwise_xor_wide_wide()
         {
             int4x3 a0 = int4x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919);
@@ -1112,7 +1112,7 @@ public static void int4x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_bitwise_xor_wide_scalar()
         {
             int4x3 a0 = int4x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786);
@@ -1136,7 +1136,7 @@ public static void int4x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1160,7 +1160,7 @@ public static void int4x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_left_shift()
         {
             int4x3 a0 = int4x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902);
@@ -1184,7 +1184,7 @@ public static void int4x3_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_right_shift()
         {
             int4x3 a0 = int4x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878);
@@ -1208,7 +1208,7 @@ public static void int4x3_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x3_operator_bitwise_not()
         {
             int4x3 a0 = int4x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785);
@@ -1228,7 +1228,7 @@ public static void int4x3_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void int4x3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new int4x3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestInt4x4.gen.cs b/src/Tests/Tests/Shared/TestInt4x4.gen.cs
index 87f3887b..81786fb7 100644
--- a/src/Tests/Tests/Shared/TestInt4x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt4x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt4x4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_zero()
         {
             TestUtils.AreEqual(0, int4x4.zero.c0.x);
@@ -36,7 +36,7 @@ public static void int4x4_zero()
             TestUtils.AreEqual(0, int4x4.zero.c3.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_identity()
         {
             TestUtils.AreEqual(1, int4x4.identity.c0.x);
@@ -57,7 +57,7 @@ public static void int4x4_identity()
             TestUtils.AreEqual(1, int4x4.identity.c3.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_equal_wide_wide()
         {
             int4x4 a0 = int4x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837, 1303661760, 2044073738, 370395888, 1822916805);
@@ -81,7 +81,7 @@ public static void int4x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_equal_wide_scalar()
         {
             int4x4 a0 = int4x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137, 712957637, 2028784869, 1049962241, 1836975611);
@@ -105,7 +105,7 @@ public static void int4x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -129,7 +129,7 @@ public static void int4x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_not_equal_wide_wide()
         {
             int4x4 a0 = int4x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545, 1211445174, 1289303469, 1436402489, 1129570126);
@@ -153,7 +153,7 @@ public static void int4x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_not_equal_wide_scalar()
         {
             int4x4 a0 = int4x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494, 507918242, 1702162286, 923269270, 166187260);
@@ -177,7 +177,7 @@ public static void int4x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -201,7 +201,7 @@ public static void int4x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_less_wide_wide()
         {
             int4x4 a0 = int4x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069, 840685445, 1220554047, 2013681746, 192965012);
@@ -225,7 +225,7 @@ public static void int4x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_less_wide_scalar()
         {
             int4x4 a0 = int4x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417, 1857132231, 1909506562, 1294006045, 952084157);
@@ -249,7 +249,7 @@ public static void int4x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -273,7 +273,7 @@ public static void int4x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_greater_wide_wide()
         {
             int4x4 a0 = int4x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903, 2029731638, 1377214212, 1207816926, 474621063);
@@ -297,7 +297,7 @@ public static void int4x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_greater_wide_scalar()
         {
             int4x4 a0 = int4x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960, 1850273578, 206147145, 325913453, 333381537);
@@ -321,7 +321,7 @@ public static void int4x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -345,7 +345,7 @@ public static void int4x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_less_equal_wide_wide()
         {
             int4x4 a0 = int4x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946, 1387761992, 195272789, 659549000, 888761458);
@@ -369,7 +369,7 @@ public static void int4x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_less_equal_wide_scalar()
         {
             int4x4 a0 = int4x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501, 518127023, 1246249980, 1097326500, 1964410699);
@@ -393,7 +393,7 @@ public static void int4x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -417,7 +417,7 @@ public static void int4x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_greater_equal_wide_wide()
         {
             int4x4 a0 = int4x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752, 424526026, 788481984, 1662488497, 870326690);
@@ -441,7 +441,7 @@ public static void int4x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_greater_equal_wide_scalar()
         {
             int4x4 a0 = int4x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390, 996159180, 2111455181, 727766399, 96217144);
@@ -465,7 +465,7 @@ public static void int4x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -489,7 +489,7 @@ public static void int4x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_add_wide_wide()
         {
             int4x4 a0 = int4x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462, 1218855698, 700538222, 1702057277, 1788251699);
@@ -513,7 +513,7 @@ public static void int4x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_add_wide_scalar()
         {
             int4x4 a0 = int4x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642, 678921480, 625943813, 512157429, 1470648741);
@@ -537,7 +537,7 @@ public static void int4x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -561,7 +561,7 @@ public static void int4x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_sub_wide_wide()
         {
             int4x4 a0 = int4x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285, 1125909359, 1842588095, 848561896, 614448464);
@@ -585,7 +585,7 @@ public static void int4x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_sub_wide_scalar()
         {
             int4x4 a0 = int4x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508, 1806482044, 1994553647, 2101812429, 1482736902);
@@ -609,7 +609,7 @@ public static void int4x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -633,7 +633,7 @@ public static void int4x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_mul_wide_wide()
         {
             int4x4 a0 = int4x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842, 522856538, 278370196, 289217012, 2083410174);
@@ -657,7 +657,7 @@ public static void int4x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_mul_wide_scalar()
         {
             int4x4 a0 = int4x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203, 638897141, 268562104, 1007838321, 1163240135);
@@ -681,7 +681,7 @@ public static void int4x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -705,7 +705,7 @@ public static void int4x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_div_wide_wide()
         {
             int4x4 a0 = int4x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736, 200852358, 129983172, 500176108, 472051781);
@@ -729,7 +729,7 @@ public static void int4x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_div_wide_scalar()
         {
             int4x4 a0 = int4x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377, 643754735, 2084019932, 2047825037, 458304263);
@@ -753,7 +753,7 @@ public static void int4x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -777,7 +777,7 @@ public static void int4x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_mod_wide_wide()
         {
             int4x4 a0 = int4x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293, 813624265, 1617478722, 498370451, 780075943);
@@ -801,7 +801,7 @@ public static void int4x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_mod_wide_scalar()
         {
             int4x4 a0 = int4x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785, 327476870, 1617696916, 379853074, 477430114);
@@ -825,7 +825,7 @@ public static void int4x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -849,7 +849,7 @@ public static void int4x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_plus()
         {
             int4x4 a0 = int4x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223, 715660442, 1995564647, 69731564, 1317851903);
@@ -869,7 +869,7 @@ public static void int4x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_neg()
         {
             int4x4 a0 = int4x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822, 2051940607, 1434247484, 485368391, 908365416);
@@ -889,7 +889,7 @@ public static void int4x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_prefix_inc()
         {
             int4x4 a0 = int4x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735, 1584496757, 1170613526, 986715680, 1701179230);
@@ -909,7 +909,7 @@ public static void int4x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_postfix_inc()
         {
             int4x4 a0 = int4x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446, 1343289659, 1227160199, 947635082, 137930180);
@@ -929,7 +929,7 @@ public static void int4x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_prefix_dec()
         {
             int4x4 a0 = int4x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220, 312317355, 1027543764, 1595492535, 1426262619);
@@ -949,7 +949,7 @@ public static void int4x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_postfix_dec()
         {
             int4x4 a0 = int4x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851, 653673271, 140452688, 1928164223, 1760916301);
@@ -969,7 +969,7 @@ public static void int4x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_bitwise_and_wide_wide()
         {
             int4x4 a0 = int4x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302, 1929998247, 1504941434, 470682792, 713577376);
@@ -993,7 +993,7 @@ public static void int4x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_bitwise_and_wide_scalar()
         {
             int4x4 a0 = int4x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546, 1873208293, 126982769, 651482651, 1383096952);
@@ -1017,7 +1017,7 @@ public static void int4x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1041,7 +1041,7 @@ public static void int4x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_bitwise_or_wide_wide()
         {
             int4x4 a0 = int4x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227, 1686257697, 2137727522, 1569900650, 856504729);
@@ -1065,7 +1065,7 @@ public static void int4x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_bitwise_or_wide_scalar()
         {
             int4x4 a0 = int4x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676, 228656898, 41280811, 1536908787, 606786773);
@@ -1089,7 +1089,7 @@ public static void int4x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1113,7 +1113,7 @@ public static void int4x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_bitwise_xor_wide_wide()
         {
             int4x4 a0 = int4x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919, 26631152, 1016475570, 1862440929, 379588576);
@@ -1137,7 +1137,7 @@ public static void int4x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_bitwise_xor_wide_scalar()
         {
             int4x4 a0 = int4x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786, 625604047, 1700827127, 2003392824, 1481813598);
@@ -1161,7 +1161,7 @@ public static void int4x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1185,7 +1185,7 @@ public static void int4x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_left_shift()
         {
             int4x4 a0 = int4x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902, 1959056531, 1779118882, 1451674188, 2082026915);
@@ -1209,7 +1209,7 @@ public static void int4x4_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_right_shift()
         {
             int4x4 a0 = int4x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878, 667378673, 1611921244, 307750782, 479442287);
@@ -1233,7 +1233,7 @@ public static void int4x4_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4x4_operator_bitwise_not()
         {
             int4x4 a0 = int4x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785, 916013379, 203444882, 1172294211, 1020232736);
@@ -1253,7 +1253,7 @@ public static void int4x4_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void int4x4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new int4x4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestMath.cs b/src/Tests/Tests/Shared/TestMath.cs
index d22d82a7..4ba1c895 100644
--- a/src/Tests/Tests/Shared/TestMath.cs
+++ b/src/Tests/Tests/Shared/TestMath.cs
@@ -8,7 +8,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public partial class TestMath
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asint_uint()
         {
             TestUtils.AreEqual(0, asint(0u));
@@ -19,7 +19,7 @@ public static void asint_uint()
             TestUtils.AreEqual(-1, asint(0xFFFFFFFFu));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asint_uint2()
         {
             TestUtils.AreEqual(int2(0, 0x12345678), asint(uint2(0u, 0x12345678u)));
@@ -27,21 +27,21 @@ public static void asint_uint2()
             TestUtils.AreEqual(int2(-2023406815, -1), asint(uint2(0x87654321u, 0xFFFFFFFFu)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asint_uint3()
         {
             TestUtils.AreEqual(int3(0, 0x12345678, 0x7FFFFFFF), asint(uint3(0u, 0x12345678u, 0x7FFFFFFFu)));
             TestUtils.AreEqual(int3(-2147483648, -2023406815, -1), asint(uint3(0x80000000u, 0x87654321u, 0xFFFFFFFFu)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asint_uint4()
         {
             TestUtils.AreEqual(int4(0, 0x12345678, 0x7FFFFFFF, -2147483648), asint(uint4(0u, 0x12345678u, 0x7FFFFFFFu, 0x80000000u)));
             TestUtils.AreEqual(int4(-2023406815, -1, 0, 0), asint(uint4(0x87654321u, 0xFFFFFFFFu, 0u, 0u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asint_float()
         {
             TestUtils.AreEqual(0, asint(0.0f));
@@ -56,14 +56,14 @@ public static void asint_float()
             TestUtils.AreEqual(unchecked((int)0xFF800000), asint(float.NegativeInfinity));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asint_float_signed_zero()
         {
             TestUtils.AreEqual(unchecked((int)0x80000000), asint(TestUtils.SignedFloatZero()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asint_float2()
         {
             TestUtils.AreEqual(int2(0, 0x3F800000), asint(float2(0.0f, 1.0f)));
@@ -75,14 +75,14 @@ public static void asint_float2()
             TestUtils.AreEqual(int2(0, 0), asint(float2(0.0f, 0.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asint_float2_signed_zero()
         {
             TestUtils.AreEqual(int2(unchecked((int)0x80000000), unchecked((int)0x80000000)), asint(float2(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asint_float3()
         {
             TestUtils.AreEqual(int3(0, 0x3F800000, 0x449A51EC), asint(float3(0.0f, 1.0f, 1234.56f)));
@@ -91,14 +91,14 @@ public static void asint_float3()
             TestUtils.AreEqual(int3(unchecked((int)0xC49A51EC), unchecked((int)0xFF800000), 0), asint(float3(-1234.56f, float.NegativeInfinity, 0.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asint_float3_signed_zero()
         {
             TestUtils.AreEqual(int3(unchecked((int)0x80000000), unchecked((int)0x80000000), unchecked((int)0x80000000)), asint(float3(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asint_float4()
         {
             TestUtils.AreEqual(int4(0, 0x3F800000, 0x449A51EC, 0x7F800000), asint(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity)));
@@ -106,14 +106,14 @@ public static void asint_float4()
             TestUtils.AreEqual(int4(unchecked((int)0x7FC00000), unchecked((int)0xBF800000), unchecked((int)0xC49A51EC), unchecked((int)0xFF800000)), asint(float4(TestUtils.UnsignedFloatQNaN(), -1.0f, -1234.56f, float.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asint_float4_signed_zero()
         {
             TestUtils.AreEqual(int4(unchecked((int)0x80000000), unchecked((int)0x80000000), unchecked((int)0x80000000), unchecked((int)0x80000000)), asint(float4(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asuint_int()
         {
             TestUtils.AreEqual(0u, asuint(0));
@@ -124,7 +124,7 @@ public static void asuint_int()
             TestUtils.AreEqual(0xFFFFFFFFu, asuint(-1));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asuint_int2()
         {
             TestUtils.AreEqual(uint2(0u, 0x12345678u), asuint(int2(0, 0x12345678)));
@@ -132,21 +132,21 @@ public static void asuint_int2()
             TestUtils.AreEqual(uint2(0x87654321u, 0xFFFFFFFFu), asuint(int2(-2023406815, -1)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asuint_int3()
         {
             TestUtils.AreEqual(uint3(0u, 0x12345678u, 0x7FFFFFFFu), asuint(int3(0, 0x12345678, 0x7FFFFFFF)));
             TestUtils.AreEqual(uint3(0x80000000u, 0x87654321u, 0xFFFFFFFFu), asuint(int3(-2147483648, -2023406815, -1)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asuint_int4()
         {
             TestUtils.AreEqual(uint4(0u, 0x12345678u, 0x7FFFFFFFu, 0x80000000u), asuint(int4(0, 0x12345678, 0x7FFFFFFF, -2147483648)));
             TestUtils.AreEqual(uint4(0x87654321u, 0xFFFFFFFFu, 0u, 0u), asuint(int4(-2023406815, -1, 0, 0)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asuint_float()
         {
             TestUtils.AreEqual(0u, asuint(0.0f));
@@ -161,14 +161,14 @@ public static void asuint_float()
             TestUtils.AreEqual(0xFF800000u, asuint(float.NegativeInfinity));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asuint_float_signed_zero()
         {
             TestUtils.AreEqual(0x80000000u, asuint(TestUtils.SignedFloatZero()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asuint_float2()
         {
             TestUtils.AreEqual(uint2(0u, 0x3F800000u), asuint(float2(0.0f, 1.0f)));
@@ -179,14 +179,14 @@ public static void asuint_float2()
             TestUtils.AreEqual(uint2(0xC49A51ECu, 0xFF800000u), asuint(float2(-1234.56f, float.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asuint_float2_signed_zero()
         {
             TestUtils.AreEqual(uint2(0x80000000u, 0x80000000u), asuint(float2(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asuint_float3()
         {
             TestUtils.AreEqual(uint3(0u, 0x3F800000u, 0x449A51ECu), asuint(float3(0.0f, 1.0f, 1234.56f)));
@@ -195,14 +195,14 @@ public static void asuint_float3()
             TestUtils.AreEqual(uint3(0xC49A51ECu, 0xff800000u, 0u), asuint(float3(-1234.56f, float.NegativeInfinity, 0.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asuint_float3_signed_zero()
         {
             TestUtils.AreEqual(uint3(0x80000000u, 0x80000000u, 0x80000000u), asuint(float3(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asuint_float4()
         {
             TestUtils.AreEqual(uint4(0u, 0x3F800000u, 0x449A51ECu, 0x7F800000u), asuint(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity)));
@@ -210,14 +210,14 @@ public static void asuint_float4()
             TestUtils.AreEqual(uint4(0x7FC00000u, 0xBF800000u, 0xC49A51ECu, 0xFF800000u), asuint(float4(TestUtils.UnsignedFloatQNaN(), -1.0f, -1234.56f, float.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asuint_float4_singed_zero()
         {
             TestUtils.AreEqual(uint4(0x80000000u, 0x80000000u, 0x80000000u, 0x80000000u), asuint(float4(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void aslong_ulong()
         {
             TestUtils.AreEqual(0L, aslong(0ul));
@@ -228,7 +228,7 @@ public static void aslong_ulong()
             TestUtils.AreEqual(-1L, aslong(0xFFFFFFFFFFFFFFFFul));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void aslong_double()
         {
             TestUtils.AreEqual(0L, aslong(0.0));
@@ -242,14 +242,14 @@ public static void aslong_double()
             TestUtils.AreEqual(unchecked((long)0xFFF0000000000000UL), aslong(double.NegativeInfinity));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void aslong_double_signed_zero()
         {
             TestUtils.AreEqual(unchecked((long)0x8000000000000000UL), aslong(TestUtils.SignedDoubleZero()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asulong_long()
         {
             TestUtils.AreEqual(0ul, asulong(0L));
@@ -260,7 +260,7 @@ public static void asulong_long()
             TestUtils.AreEqual(0xFFFFFFFFFFFFFFFFul, asulong(-1L));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asulong_double()
         {
             TestUtils.AreEqual(0UL, asulong(0.0));
@@ -274,14 +274,14 @@ public static void asulong_double()
             TestUtils.AreEqual(0xFFF0000000000000UL, asulong(double.NegativeInfinity));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asulong_double_signed_zero()
         {
             TestUtils.AreEqual(0x8000000000000000UL, asulong(TestUtils.SignedDoubleZero()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asfloat_int()
         {
             TestUtils.AreEqual(0.0f, asfloat(0));
@@ -297,7 +297,7 @@ public static void asfloat_int()
             TestUtils.AreEqual(asuint(TestUtils.UnsignedFloatQNaN()), asuint(asfloat(unchecked((int)0x7FC00000))));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asfloat_int2()
         {
             TestUtils.AreEqual(float2(0.0f, 1.0f), asfloat(int2(0, 0x3F800000)));
@@ -309,7 +309,7 @@ public static void asfloat_int2()
             TestUtils.AreEqual(asuint(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(int2(unchecked((int)0x7FC00000), unchecked((int)0x7FC00000)))));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asfloat_int3()
         {
             TestUtils.AreEqual(float3(0.0f, 1.0f, 1234.56f), asfloat(int3(0, 0x3F800000, 0x449A51EC)));
@@ -320,7 +320,7 @@ public static void asfloat_int3()
             TestUtils.AreEqual(asuint(float3(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(int3(unchecked((int)0x7FC00000), unchecked((int)0x7FC00000), unchecked((int)0x7FC00000)))));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asfloat_int4()
         {
             TestUtils.AreEqual(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity), asfloat(int4(0, 0x3F800000, 0x449A51EC, 0x7F800000)));
@@ -330,7 +330,7 @@ public static void asfloat_int4()
             TestUtils.AreEqual(asuint(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(int4(unchecked((int)0x7FC00000), unchecked((int)0x7FC00000), unchecked((int)0x7FC00000), unchecked((int)0x7FC00000)))));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asfloat_uint()
         {
             TestUtils.AreEqual(0.0f, asfloat(0u));
@@ -346,7 +346,7 @@ public static void asfloat_uint()
             TestUtils.AreEqual(asuint(TestUtils.UnsignedFloatQNaN()), asuint(asfloat(0x7FC00000u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asfloat_uint2()
         {
             TestUtils.AreEqual(float2(0.0f, 1.0f), asfloat(uint2(0u, 0x3F800000u)));
@@ -358,7 +358,7 @@ public static void asfloat_uint2()
             TestUtils.AreEqual(asuint(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(uint2(0x7FC00000u, 0x7FC00000u))));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asfloat_uint3()
         {
             TestUtils.AreEqual(float3(0.0f, 1.0f, 1234.56f), asfloat(uint3(0u, 0x3F800000u, 0x449A51ECu)));
@@ -369,7 +369,7 @@ public static void asfloat_uint3()
             TestUtils.AreEqual(asuint(float3(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(uint3(0x7FC00000u, 0x7FC00000u, 0x7FC00000u))));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asfloat_uint4()
         {
             TestUtils.AreEqual(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity), asfloat(uint4(0u, 0x3F800000u, 0x449A51ECu, 0x7F800000u)));
@@ -379,7 +379,7 @@ public static void asfloat_uint4()
             TestUtils.AreEqual(asuint(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(uint4(0x7FC00000u, 0x7FC00000u, 0x7FC00000u, 0x7FC00000u))));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asdouble_long()
         {
             TestUtils.AreEqual(0.0, asdouble(0L));
@@ -394,7 +394,7 @@ public static void asdouble_long()
             TestUtils.AreEqual(double.NegativeInfinity, asdouble(unchecked((long)0xFFF0000000000000UL)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void asdouble_ulong()
         {
             TestUtils.AreEqual(0.0, asdouble(0UL));
@@ -409,7 +409,7 @@ public static void asdouble_ulong()
             TestUtils.AreEqual(double.NegativeInfinity, asdouble(0xFFF0000000000000UL));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void faceforward_float2()
         {
             TestUtils.AreEqual(float2(-3.5f, 4.5f), faceforward(float2(3.5f, -4.5f), float2(1.0f, -2.0f), float2(3.0f, -4.0f)));
@@ -417,7 +417,7 @@ public static void faceforward_float2()
             TestUtils.AreEqual(float2(-3.5f, 4.5f), faceforward(float2(3.5f, -4.5f), float2(1.0f, -2.0f), float2(0.0f, 0.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void faceforward_float3()
         {
             TestUtils.AreEqual(float3(-3.5f, 4.5f, -5.5f), faceforward(float3(3.5f, -4.5f, 5.5f), float3(1.0f, -2.0f, 3.0f), float3(3.0f, -4.0f, 5.0f)));
@@ -425,7 +425,7 @@ public static void faceforward_float3()
             TestUtils.AreEqual(float3(-3.5f, 4.5f, -5.5f), faceforward(float3(3.5f, -4.5f, 5.5f), float3(1.0f, -2.0f, 3.0f), float3(0.0f, 0.0f, 0.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void faceforward_float4()
         {
             TestUtils.AreEqual(float4(-3.5f, 4.5f, -5.5f, 6.5f), faceforward(float4(3.5f, -4.5f, 5.5f, -6.5f), float4(1.0f, -2.0f, 3.0f, -4.0f), float4(3.0f, -4.0f, 5.0f, -6.0f)));
@@ -433,7 +433,7 @@ public static void faceforward_float4()
             TestUtils.AreEqual(float4(-3.5f, 4.5f, -5.5f, 6.5f), faceforward(float4(3.5f, -4.5f, 5.5f, -6.5f), float4(1.0f, -2.0f, 3.0f, -4.0f), float4(0.0f, 0.0f, 0.0f, 0.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void faceforward_double2()
         {
             TestUtils.AreEqual(double2(-3.5, 4.5), faceforward(double2(3.5, -4.5), double2(1.0, -2.0), double2(3.0, -4.0)));
@@ -441,7 +441,7 @@ public static void faceforward_double2()
             TestUtils.AreEqual(double2(-3.5, 4.5), faceforward(double2(3.5, -4.5), double2(1.0, -2.0), double2(0.0, 0.0)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void faceforward_double3()
         {
             TestUtils.AreEqual(double3(-3.5, 4.5, -5.5), faceforward(double3(3.5, -4.5, 5.5), double3(1.0, -2.0, 3.0), double3(3.0, -4.0, 5.0)));
@@ -449,7 +449,7 @@ public static void faceforward_double3()
             TestUtils.AreEqual(double3(-3.5, 4.5, -5.5), faceforward(double3(3.5, -4.5, 5.5), double3(1.0, -2.0, 3.0), double3(0.0, 0.0, 0.0)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void faceforward_double4()
         {
             TestUtils.AreEqual(double4(-3.5, 4.5, -5.5, 6.5), faceforward(double4(3.5, -4.5, 5.5, -6.5), double4(1.0, -2.0, 3.0, -4.0), double4(3.0, -4.0, 5.0, -6.0)));
@@ -457,7 +457,7 @@ public static void faceforward_double4()
             TestUtils.AreEqual(double4(-3.5, 4.5, -5.5, 6.5), faceforward(double4(3.5, -4.5, 5.5, -6.5), double4(1.0, -2.0, 3.0, -4.0), double4(0.0, 0.0, 0.0, 0.0)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void modf_float()
         {
             float f, i;
@@ -474,7 +474,7 @@ public static void modf_float()
             TestUtils.AreEqual(0.0f, f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void modf_float2()
         {
             float2 f, i;
@@ -487,7 +487,7 @@ public static void modf_float2()
             TestUtils.AreEqual(float2(0.0f, 0.5f), f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void modf_float3()
         {
             float3 f, i;
@@ -496,7 +496,7 @@ public static void modf_float3()
             TestUtils.AreEqual(float3(0.75f, -0.25f, 0.0f), f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void modf_float4()
         {
             float4 f, i;
@@ -505,7 +505,7 @@ public static void modf_float4()
             TestUtils.AreEqual(float4(0.75f, -0.25f, 0.0f, 0.5f), f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void modf_double()
         {
             double f, i;
@@ -522,7 +522,7 @@ public static void modf_double()
             TestUtils.AreEqual(0.0, f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void modf_double2()
         {
             double2 f, i;
@@ -535,7 +535,7 @@ public static void modf_double2()
             TestUtils.AreEqual(double2(0.0, 0.5), f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void modf_double3()
         {
             double3 f, i;
@@ -544,7 +544,7 @@ public static void modf_double3()
             TestUtils.AreEqual(double3(0.75, -0.25, 0.0), f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void modf_double4()
         {
             double4 f, i;
@@ -553,21 +553,21 @@ public static void modf_double4()
             TestUtils.AreEqual(double4(0.75, -0.25, 0.0, 0.5f), f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void normalize_float2()
         {
             TestUtils.AreEqual(float2(0.504883f, -0.863188f), normalize(float2(3.1f, -5.3f)), 0.0001f);
             TestUtils.AreEqual(true, all(isnan(normalize(float2(0.0f, 0.0f)))));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void normalize_float3()
         {
             TestUtils.AreEqual(float3(0.464916f, -0.794861f, 0.389932f), normalizesafe(float3(3.1f, -5.3f, 2.6f)), 0.0001f);
             TestUtils.AreEqual(true, all(isnan(normalize(float3(0.0f, 0.0f, 0.0f)))));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void normalize_float4()
         {
             TestUtils.AreEqual(float4(0.234727f, -0.401308f, 0.196868f, 0.863191f), normalizesafe(float4(3.1f, -5.3f, 2.6f, 11.4f)), 0.0001f);
@@ -575,28 +575,28 @@ public static void normalize_float4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void normalize_double2()
         {
             TestUtils.AreEqual(double2(0.504883, -0.863188), normalize(double2(3.1, -5.3)), 0.0001);
             TestUtils.AreEqual(true, all(isnan(normalize(double2(0.0, 0.0)))));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void normalize_double3()
         {
             TestUtils.AreEqual(double3(0.464916, -0.794861, 0.389932), normalizesafe(double3(3.1, -5.3, 2.6)), 0.0001);
             TestUtils.AreEqual(true, all(isnan(normalize(double3(0.0, 0.0, 0.0)))));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void normalize_double4()
         {
             TestUtils.AreEqual(double4(0.234727, -0.401308, 0.196868, 0.863191), normalizesafe(double4(3.1, -5.3, 2.6, 11.4)), 0.0001);
             TestUtils.AreEqual(true, all(isnan(normalize(double4(0.0, 0.0, 0.0, 0.0f)))));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void normalize_quaternion()
         {
             TestUtils.AreEqual(quaternion(0.234727f, -0.401308f, 0.196868f, 0.863191f), normalizesafe(quaternion(3.1f, -5.3f, 2.6f, 11.4f)), 0.0001f);
@@ -604,7 +604,7 @@ public static void normalize_quaternion()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void normalizesafe_float2()
         {
             TestUtils.AreEqual(float2(0.504883f, -0.863188f), normalizesafe(float2(3.1f, -5.3f)), 0.0001f);
@@ -614,7 +614,7 @@ public static void normalizesafe_float2()
             TestUtils.AreEqual(float2(1.0f, 2.0f), normalizesafe(float2(7.66e-20f, 7.66e-20f), float2(1.0f, 2.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void normalizesafe_float3()
         {
             TestUtils.AreEqual(float3(0.464916f, -0.794861f, 0.389932f), normalizesafe(float3(3.1f, -5.3f, 2.6f)), 0.0001f);
@@ -624,7 +624,7 @@ public static void normalizesafe_float3()
             TestUtils.AreEqual(float3(1.0f, 2.0f, 3.0f), normalizesafe(float3(6.25e-20f, 6.25e-20f, 6.25e-20f), float3(1.0f, 2.0f, 3.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void normalizesafe_float4()
         {
             TestUtils.AreEqual(float4(0.234727f, -0.401308f, 0.196868f, 0.863191f), normalizesafe(float4(3.1f, -5.3f, 2.6f, 11.4f)), 0.0001f);
@@ -635,7 +635,7 @@ public static void normalizesafe_float4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void normalizesafe_double2()
         {
             TestUtils.AreEqual(double2(0.504883, -0.863188), normalizesafe(double2(3.1, -5.3)), 0.0001);
@@ -645,7 +645,7 @@ public static void normalizesafe_double2()
             TestUtils.AreEqual(double2(1.0, 2.0), normalizesafe(double2(1.05e-154, 1.05e-154), double2(1.0, 2.0)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void normalizesafe_double3()
         {
             TestUtils.AreEqual(double3(0.464916, -0.794861, 0.389932), normalizesafe(double3(3.1, -5.3, 2.6)), 0.0001);
@@ -655,7 +655,7 @@ public static void normalizesafe_double3()
             TestUtils.AreEqual(double3(1.0, 2.0, 3.0), normalizesafe(double3(8.61e-155, 8.61e-155, 8.61e-155), double3(1.0, 2.0, 3.0)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void normalizesafe_double4()
         {
             TestUtils.AreEqual(double4(0.234727, -0.401308, 0.196868, 0.863191), normalizesafe(double4(3.1, -5.3, 2.6, 11.4)), 0.0001);
@@ -665,7 +665,7 @@ public static void normalizesafe_double4()
             TestUtils.AreEqual(double4(1.0, 2.0, 3.0, 4.0), normalizesafe(double4(7.45e-155, 7.45e-155, 7.45e-155, 7.45e-155), double4(1.0, 2.0, 3.0, 4.0)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void normalizesafe_quaternion()
         {
             TestUtils.AreEqual(quaternion(0.234727f, -0.401308f, 0.196868f, 0.863191f), normalizesafe(quaternion(3.1f, -5.3f, 2.6f, 11.4f)), 0.0001f);
@@ -675,7 +675,7 @@ public static void normalizesafe_quaternion()
             TestUtils.AreEqual(quaternion(1.0f, 2.0f, 3.0f, 4.0f), normalizesafe(quaternion(5.42e-20f, 5.42e-20f, 5.42e-20f, 5.42e-20f), quaternion(1.0f, 2.0f, 3.0f, 4.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void f16tof32_float()
         {
             TestUtils.AreEqual(0x00000000, asuint(f16tof32(0x0000)));
@@ -693,7 +693,7 @@ public static void f16tof32_float()
             TestUtils.AreEqual(true, isnan(f16tof32(0xFC01)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void f16tof32_float2()
         {
             TestUtils.AreEqual(uint2(0x00000000, 0x3800C000), asuint(f16tof32(uint2(0x0000, 0x0203))));
@@ -707,7 +707,7 @@ public static void f16tof32_float2()
             TestUtils.AreEqual(true, all(isnan(f16tof32(uint2(0xFC01, 0xFC01)))));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void f16tof32_float3()
         {
             TestUtils.AreEqual(uint3(0x00000000, 0x3800C000, 0x40642000), asuint(f16tof32(uint3(0x0000, 0x0203, 0x4321))));
@@ -719,7 +719,7 @@ public static void f16tof32_float3()
             TestUtils.AreEqual(true, all(isnan(f16tof32(uint3(0xFC01, 0xFC01, 0xFC01)))));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void f16tof32_float4()
         {
             TestUtils.AreEqual(uint4(0x00000000, 0x3800C000, 0x40642000, 0x477FE000), asuint(f16tof32(uint4(0x0000, 0x0203, 0x4321, 0x7BFF))));
@@ -731,7 +731,7 @@ public static void f16tof32_float4()
             TestUtils.AreEqual(true, all(isnan(f16tof32(uint4(0xFC01, 0xFC01, 0xFC01, 0xFC01)))));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void f32tof16_float()
         {
             TestUtils.AreEqual(0x0000, f32tof16(0.0f));
@@ -751,14 +751,14 @@ public static void f32tof16_float()
             TestUtils.AreEqual(0xFC00, f32tof16(float.NegativeInfinity));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void f32tof16_float_signed_zero()
         {
             TestUtils.AreEqual(0x8000, f32tof16(TestUtils.SignedFloatZero()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void f32tof16_float2()
         {
             TestUtils.AreEqual(uint2(0x0000, 0x0000), f32tof16(float2(0.0f, 2.98e-08f)));
@@ -772,14 +772,14 @@ public static void f32tof16_float2()
             TestUtils.AreEqual(uint2(0xFC00, 0x0000), f32tof16(float2(float.NegativeInfinity, 0.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void f32tof16_float2_signed_zero()
         {
             TestUtils.AreEqual(uint2(0x8000, 0x8000), f32tof16(float2(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void f32tof16_float3()
         {
             TestUtils.AreEqual(uint3(0x0000, 0x0000, 0x0001), f32tof16(float3(0.0f, 2.98e-08f, 5.96046448e-08f)));
@@ -790,14 +790,14 @@ public static void f32tof16_float3()
             TestUtils.AreEqual(uint3(0xFC00, 0xFC00, 0x0000), f32tof16(float3(-65520.0f, float.NegativeInfinity, 0.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void f32tof16_float3_signed_zero()
         {
             TestUtils.AreEqual(uint3(0x8000, 0x8000, 0x8000), f32tof16(float3(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void f32tof16_float4()
         {
             TestUtils.AreEqual(uint4(0x0000, 0x0000, 0x0001, 0x57B6), f32tof16(float4(0.0f, 2.98e-08f, 5.96046448e-08f, 123.4f)));
@@ -806,14 +806,14 @@ public static void f32tof16_float4()
             TestUtils.AreEqual(uint4(0xFC00, 0xFC00, 0xFC00, 0x0000), f32tof16(float4(-65520.0f, float.NegativeInfinity, float.NegativeInfinity, 0.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void f32tof16_float4_signed_zero()
         {
             TestUtils.AreEqual(uint4(0x8000, 0x8000, 0x8000, 0x8000), f32tof16(float4(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void reflect_float2()
         {
             TestUtils.AreEqual(float2(9.84f, -3.888f), reflect(float2(1.2f, 3.6f), float2(1.5f, -1.3f)), 8, false);
@@ -822,7 +822,7 @@ public static void reflect_float2()
             TestUtils.AreEqual(float2(0.0f, 0.0f), reflect(float2(0.0f, 0.0f), float2(-1.5f, -1.3f)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void reflect_float3()
         {
             TestUtils.AreEqual(float3(35.88f, -26.456f, 68.872f), reflect(float3(1.2f, 3.6f, -2.8f), float3(1.5f, -1.3f, 3.1f)), 8, false);
@@ -831,7 +831,7 @@ public static void reflect_float3()
             TestUtils.AreEqual(float3(0.0f, 0.0f, 0.0f), reflect(float3(0.0f, 0.0f, 0.0f), float3(-1.5f, -1.3f, 3.1f)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void reflect_float4()
         {
             TestUtils.AreEqual(float4(36.51f, -27.002f, 70.174f, -16.178f), reflect(float4(1.2f, 3.6f, -2.8f, 0.3f), float4(1.5f, -1.3f, 3.1f, -0.7f)), 8, false);
@@ -841,7 +841,7 @@ public static void reflect_float4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void reflect_double2()
         {
             TestUtils.AreEqual(double2(9.84, -3.888), reflect(double2(1.2, 3.6), double2(1.5, -1.3)), 8, false);
@@ -850,7 +850,7 @@ public static void reflect_double2()
             TestUtils.AreEqual(double2(0.0, 0.0), reflect(double2(0.0, 0.0), double2(-1.5, -1.3)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void reflect_double3()
         {
             TestUtils.AreEqual(double3(35.88, -26.456, 68.872), reflect(double3(1.2, 3.6, -2.8), double3(1.5, -1.3, 3.1)), 8, false);
@@ -859,7 +859,7 @@ public static void reflect_double3()
             TestUtils.AreEqual(double3(0.0, 0.0, 0.0), reflect(double3(0.0, 0.0, 0.0), double3(-1.5f, -1.3, 3.1)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void reflect_double4()
         {
             TestUtils.AreEqual(double4(36.51, -27.002, 70.174, -16.178), reflect(double4(1.2, 3.6, -2.8, 0.3), double4(1.5, -1.3, 3.1, -0.7)), 8, false);
@@ -869,7 +869,7 @@ public static void reflect_double4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void refract_float2()
         {
             TestUtils.AreEqual(float2(-0.3676186f, 0.9299768f), refract(float2(0.316228f, 0.948683f), float2(0.755689f, -0.654931f), 0.5f), 8, false);
@@ -877,7 +877,7 @@ public static void refract_float2()
             TestUtils.AreEqual(float2(0.0f, 0.0f), refract(float2(0.316228f, 0.948683f), float2(0.755689f, -0.654931f), 1.5f));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void refract_float3()
         {
             TestUtils.AreEqual(float3(-0.2863437f, 0.8056898f, -0.5185286f), refract(float3(0.288375f, 0.865125f, -0.410365f), float3(0.662147f, -0.573861f, 0.481919f), 0.5f), 8, false);
@@ -885,7 +885,7 @@ public static void refract_float3()
             TestUtils.AreEqual(float3(0.0f, 0.0f, 0.0f), refract(float3(0.288375f, 0.865125f, -0.410365f), float3(0.662147f, -0.573861f, 0.481919f), 1.5f));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void refract_float4()
         {
             TestUtils.AreEqual(float4(-0.302029191645545f, 0.799522577847971f, -0.518952508802814f, -0.015196476378571f), refract(float4(0.278154f, 0.834461f, -0.39582f, -0.26388f), float4(0.652208f, -0.565247f, 0.474685f, -0.1726139f), 0.5f), 16, false);
@@ -894,7 +894,7 @@ public static void refract_float4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void refract_double2()
         {
             TestUtils.AreEqual(double2(-0.367618540673032, 0.929976739623085), refract(double2(0.316228, 0.948683), double2(0.755689, -0.654931), 0.5), 8, false);
@@ -902,7 +902,7 @@ public static void refract_double2()
             TestUtils.AreEqual(double2(0.0, 0.0), refract(double2(0.316228, 0.948683), double2(0.755689, -0.654931), 1.5));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void refract_double3()
         {
             TestUtils.AreEqual(double3(-0.286343746291412, 0.805689753507206, -0.518528611485079), refract(double3(0.288375, 0.865125, -0.410365), double3(0.662147, -0.573861, 0.481919), 0.5), 8, false);
@@ -910,7 +910,7 @@ public static void refract_double3()
             TestUtils.AreEqual(double3(0.0, 0.0, 0.0), refract(double3(0.288375, 0.865125, -0.410365), double3(0.662147, -0.573861, 0.481919), 1.5));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void refract_double4()
         {
             TestUtils.AreEqual(double4(-0.302029191645545, 0.799522577847971, -0.518952508802814, -0.015196476378571), refract(double4(0.278154, 0.834461, -0.39582, -0.26388), double4(0.652208, -0.565247, 0.474685, -0.1726139), 0.5), 16, false);
@@ -918,7 +918,7 @@ public static void refract_double4()
             TestUtils.AreEqual(double4(0.0, 0.0, 0.0, 0.0), refract(double4(0.278154, 0.834461, -0.39582, -0.26388), double4(0.652208, -0.565247, 0.474685, -0.172613), 1.5));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void project_float2()
         {
             var a = float2(-0.161021441221237182617f, 0.429202795028686523438f);
@@ -927,7 +927,7 @@ public static void project_float2()
             TestUtils.AreEqual(float2(1.0f, 0.0f), project(float2(1.0f), float2(1.0f, 0.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void project_float3()
         {
             var a = float3(0.394884318113327026367f, 0.148208647966384887695f, -0.264224529266357421875f);
@@ -936,7 +936,7 @@ public static void project_float3()
             TestUtils.AreEqual(float3(1.0f, 0.0f, 0.0f), project(float3(1.0f), float3(1.0f, 0.0f, 0.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void project_float4()
         {
             var a = float4(0.122686818242073059082f, 0.465182095766067504883f, -0.388583064079284667969f, -0.15201015770435333252f);
@@ -945,7 +945,7 @@ public static void project_float4()
             TestUtils.AreEqual(float4(1.0f, 0.0f, 0.0f, 0.0f), project(float4(1.0f), float4(1.0f, 0.0f, 0.0f, 0.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void projectsafe_float2()
         {
             var a = float2(-0.161021441221237182617f, 0.429202795028686523438f);
@@ -957,7 +957,7 @@ public static void projectsafe_float2()
             TestUtils.AreEqual(float2(4.0f), projectsafe(float2(NAN), float2(0.0f), float2(4.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void projectsafe_float3()
         {
             var a = float3(0.394884318113327026367f, 0.148208647966384887695f, -0.264224529266357421875f);
@@ -969,7 +969,7 @@ public static void projectsafe_float3()
             TestUtils.AreEqual(float3(4.0f), projectsafe(float3(NAN), float3(0.0f), float3(4.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void projectsafe_float4()
         {
             var a = float4(0.122686818242073059082f, 0.465182095766067504883f, -0.388583064079284667969f, -0.15201015770435333252f);
@@ -981,7 +981,7 @@ public static void projectsafe_float4()
             TestUtils.AreEqual(float4(4.0f), projectsafe(float4(NAN), float4(0.0f), float4(4.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void project_double2()
         {
             var a = double2(-0.435219509355847911092, -0.359623376546357509387);
@@ -991,7 +991,7 @@ public static void project_double2()
             TestUtils.AreEqual(double2.zero, projectsafe(a, double2(DBL_MIN_NORMAL)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void project_double3()
         {
             var a = double3(-0.3102470377532390855, -0.255432695780735075086, -0.180834679740036918805);
@@ -1001,7 +1001,7 @@ public static void project_double3()
             TestUtils.AreEqual(double3.zero, projectsafe(a, double3(DBL_MIN_NORMAL)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void project_double4()
         {
             var a = double4(0.452051837682779789063, -0.0365627422588526429514, 0.236716008642456676725, 0.397823192622046239997);
@@ -1011,7 +1011,7 @@ public static void project_double4()
             TestUtils.AreEqual(double4.zero, projectsafe(a, double4(DBL_MIN_NORMAL)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void projectsafe_double2()
         {
             var a = double2(-0.435219509355847911092, -0.359623376546357509387);
@@ -1023,7 +1023,7 @@ public static void projectsafe_double2()
             TestUtils.AreEqual(double2(4.0), projectsafe(double2(NAN_DBL), double2(0.0), double2(4.0)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void projectsafe_double3()
         {
             var a = double3(-0.3102470377532390855, -0.255432695780735075086, -0.180834679740036918805);
@@ -1035,7 +1035,7 @@ public static void projectsafe_double3()
             TestUtils.AreEqual(double3(4.0), projectsafe(double3(NAN_DBL), double3(0.0), double3(4.0)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void projectsafe_double4()
         {
             var a = double4(0.452051837682779789063, -0.0365627422588526429514, 0.236716008642456676725, 0.397823192622046239997);
@@ -1047,7 +1047,7 @@ public static void projectsafe_double4()
             TestUtils.AreEqual(double4(4.0), projectsafe(double4(NAN_DBL), double4(0.0), double4(4.0)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sincos_float()
         {
             float s, c;
@@ -1086,7 +1086,7 @@ public static void sincos_float()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sincos_float2()
         {
             float2 s, c;
@@ -1108,7 +1108,7 @@ public static void sincos_float2()
             TestUtils.AreEqual(float2(float.NaN, float.NaN), c, 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sincos_float3()
         {
             float3 s, c;
@@ -1126,7 +1126,7 @@ public static void sincos_float3()
             TestUtils.AreEqual(float3(float.NaN, float.NaN, float.NaN), c, 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sincos_float4()
         {
             float4 s, c;
@@ -1140,7 +1140,7 @@ public static void sincos_float4()
             TestUtils.AreEqual(float4(0.936752141f, float.NaN, float.NaN, float.NaN), c, 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sincos_double()
         {
             double s, c;
@@ -1177,7 +1177,7 @@ public static void sincos_double()
             TestUtils.AreEqual(double.NaN, c, 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sincos_double2()
         {
             double2 s, c;
@@ -1198,7 +1198,7 @@ public static void sincos_double2()
             TestUtils.AreEqual(double2(double.NaN, double.NaN), c, 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sincos_double3()
         {
             double3 s, c;
@@ -1216,7 +1216,7 @@ public static void sincos_double3()
             TestUtils.AreEqual(double3(double.NaN, double.NaN, double.NaN), c, 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sincos_double4()
         {
             double4 s, c;
@@ -1230,14 +1230,14 @@ public static void sincos_double4()
             TestUtils.AreEqual(double4(0.93675212753314474, double.NaN, double.NaN, double.NaN), c, 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_int()
         {
             TestUtils.AreEqual(-123456789, select(-123456789, 987654321, false));
             TestUtils.AreEqual(987654321, select(-123456789, 987654321, true));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_int2()
         {
             TestUtils.AreEqual(int2(-123456789, -123456790), select(int2(-123456789, -123456790), int2(987654321, 987654322), false));
@@ -1249,7 +1249,7 @@ public static void select_int2()
             TestUtils.AreEqual(int2(987654321, 987654322), select(int2(-123456789, -123456790), int2(987654321, 987654322), bool2(true, true)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_int3()
         {
             TestUtils.AreEqual(int3(-123456789, -123456790, -123456791), select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), false));
@@ -1266,7 +1266,7 @@ public static void select_int3()
             TestUtils.AreEqual(int3(987654321, 987654322, 987654323), select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), bool3(true, true, true)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_int4()
         {
             TestUtils.AreEqual(int4(-123456789, -123456790, -123456791, -123456792), select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), false));
@@ -1293,14 +1293,14 @@ public static void select_int4()
             TestUtils.AreEqual(int4(987654321, 987654322, 987654323, 987654324), select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(true, true, true, true)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_uint()
         {
             TestUtils.AreEqual(123456789u, select(123456789u, 987654321u, false));
             TestUtils.AreEqual(987654321u, select(123456789u, 987654321u, true));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_uint2()
         {
             TestUtils.AreEqual(uint2(123456789u, 123456790u), select(uint2(123456789u, 123456790u), uint2(987654321u, 987654322u), false));
@@ -1312,7 +1312,7 @@ public static void select_uint2()
             TestUtils.AreEqual(uint2(987654321u, 987654322u), select(uint2(123456789u, 123456790u), uint2(987654321u, 987654322u), bool2(true, true)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_uint3()
         {
             TestUtils.AreEqual(uint3(123456789u, 123456790u, 123456791u), select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), false));
@@ -1329,7 +1329,7 @@ public static void select_uint3()
             TestUtils.AreEqual(uint3(987654321u, 987654322u, 987654323u), select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), bool3(true, true, true)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_uint4()
         {
             TestUtils.AreEqual(uint4(123456789u, 123456790u, 123456791u, 123456792u), select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), false));
@@ -1356,14 +1356,14 @@ public static void select_uint4()
             TestUtils.AreEqual(uint4(987654321u, 987654322u, 987654323u, 987654324u), select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(true, true, true, true)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_long()
         {
             TestUtils.AreEqual(-12345678910111314L, select(-12345678910111314L, 987654321011121314L, false));
             TestUtils.AreEqual(987654321011121314L, select(-12345678910111314L, 987654321011121314L, true));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_ulong()
         {
             TestUtils.AreEqual(12345678910111314UL, select(12345678910111314UL, 987654321011121314UL, false));
@@ -1371,14 +1371,14 @@ public static void select_ulong()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_float()
         {
             TestUtils.AreEqual(-1234.5f, select(-1234.5f, 9876.25f, false));
             TestUtils.AreEqual(9876.25f, select(-1234.5f, 9876.25f, true));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_float2()
         {
             TestUtils.AreEqual(float2(-1234.5f, -1235.5f), select(float2(-1234.5f, -1235.5f), float2(9876.25f, 9877.25f), false));
@@ -1390,7 +1390,7 @@ public static void select_float2()
             TestUtils.AreEqual(float2(9876.25f, 9877.25f), select(float2(-1234.5f, -1235.5f), float2(9876.25f, 9877.25f), bool2(true, true)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_float3()
         {
             TestUtils.AreEqual(float3(-1234.5f, -1235.5f, -1236.5f), select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), false));
@@ -1407,7 +1407,7 @@ public static void select_float3()
             TestUtils.AreEqual(float3(9876.25f, 9877.25f, 9878.25f), select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), bool3(true, true, true)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_float4()
         {
             TestUtils.AreEqual(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), false));
@@ -1435,14 +1435,14 @@ public static void select_float4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_double()
         {
             TestUtils.AreEqual(-1234.5, select(-1234.5, 9876.25, false));
             TestUtils.AreEqual(9876.25, select(-1234.5, 9876.25, true));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_double2()
         {
             TestUtils.AreEqual(double2(-1234.5, -1235.5), select(double2(-1234.5, -1235.5), double2(9876.25, 9877.25), false));
@@ -1454,7 +1454,7 @@ public static void select_double2()
             TestUtils.AreEqual(double2(9876.25, 9877.25), select(double2(-1234.5, -1235.5), double2(9876.25, 9877.25), bool2(true, true)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_double3()
         {
             TestUtils.AreEqual(double3(-1234.5, -1235.5, -1236.5), select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), false));
@@ -1471,7 +1471,7 @@ public static void select_double3()
             TestUtils.AreEqual(double3(9876.25, 9877.25, 9878.25), select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), bool3(true, true, true)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void select_double4()
         {
             TestUtils.AreEqual(double4(-1234.5, -1235.5, -1236.5, -1237.5), select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), false));
@@ -1499,7 +1499,7 @@ public static void select_double4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void dot_int()
         {
             TestUtils.AreEqual(133, dot(7, 19));
@@ -1508,7 +1508,7 @@ public static void dot_int()
             TestUtils.AreEqual(667585376, dot(61031, 81312));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void dot_int2()
         {
             TestUtils.AreEqual(322, dot(int2(7, 9), int2(19, 21)));
@@ -1517,7 +1517,7 @@ public static void dot_int2()
             TestUtils.AreEqual(1840235232, dot(int2(61031, -12534), int2(-41312, -5312)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void dot_int3()
         {
             TestUtils.AreEqual(582, dot(int3(7, 9, 13), int3(19, 21, 20)));
@@ -1526,7 +1526,7 @@ public static void dot_int3()
             TestUtils.AreEqual(1636460279, dot(int3(61031, -12534, 9211), int3(-41312, -5312, -22123)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void dot_int4()
         {
             TestUtils.AreEqual(990, dot(int4(7, 9, 13, 17), int4(19, 21, 20, 24)));
@@ -1536,28 +1536,28 @@ public static void dot_int4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void dot_uint()
         {
             TestUtils.AreEqual(133u, dot(7u, 19u));
             TestUtils.AreEqual(667585376u, dot(61031u, 81312u));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void dot_uint2()
         {
             TestUtils.AreEqual(322, dot(uint2(7u, 9u), uint2(19u, 21u)));
             TestUtils.AreEqual(734165984u, dot(uint2(61031u, 12534u), uint2(81312u, 5312u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void dot_uint3()
         {
             TestUtils.AreEqual(582u, dot(uint3(7u, 9u, 13u), uint3(19u, 21u, 20u)));
             TestUtils.AreEqual(937940937u, dot(uint3(61031u, 12534u, 9211u), uint3(81312u, 5312u, 22123u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void dot_uint4()
         {
             TestUtils.AreEqual(990u, dot(uint4(7u, 9u, 13u, 17u), uint4(19u, 21u, 20u, 24u)));
@@ -1565,7 +1565,7 @@ public static void dot_uint4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void dot_float()
         {
             TestUtils.AreEqual(7.32f, dot(1.2f, 6.1f), 1, false);
@@ -1576,7 +1576,7 @@ public static void dot_float()
             TestUtils.AreEqual(float.NegativeInfinity, dot(1.2e19f, -6.1e19f), 0, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void dot_float2()
         {
             TestUtils.AreEqual(57.92f, dot(float2(1.2f, 5.5f), float2(6.1f, 9.2f)), 1, false);
@@ -1587,7 +1587,7 @@ public static void dot_float2()
             TestUtils.AreEqual(float.NegativeInfinity, dot(float2(-1.2e18f, 5.5e18f), float2(6.1e19f, -9.2e19f)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void dot_float3()
         {
             TestUtils.AreEqual(67.1f, dot(float3(1.2f, 5.5f, 3.4f), float3(6.1f, 9.2f, 2.7f)), 8, false);
@@ -1598,7 +1598,7 @@ public static void dot_float3()
             TestUtils.AreEqual(float.NegativeInfinity, dot(float3(-1.2e18f, 5.5e18f, 3.4e18f), float3(6.1e19f, -9.2e19f, -2.7e19f)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void dot_float4()
         {
             TestUtils.AreEqual(68.57f, dot(float4(1.2f, 5.5f, 3.4f, 4.9f), float4(6.1f, 9.2f, 2.7f, 0.3f)), 8, false);
@@ -1620,7 +1620,7 @@ public static void dot_double()
             TestUtils.AreEqual(double.NegativeInfinity, dot(1.2e19, -6.1e19), 0, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void dot_double2()
         {
             TestUtils.AreEqual(57.92, dot(double2(1.2, 5.5), double2(6.1, 9.2)), 1, false);
@@ -1631,7 +1631,7 @@ public static void dot_double2()
             TestUtils.AreEqual(double.NegativeInfinity, dot(double2(-1.2e153, 5.5e153), double2(6.1e154, -9.2e154)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void dot_double3()
         {
             TestUtils.AreEqual(67.1, dot(double3(1.2, 5.5, 3.4), double3(6.1, 9.2, 2.7)), 8, false);
@@ -1642,7 +1642,7 @@ public static void dot_double3()
             TestUtils.AreEqual(double.NegativeInfinity, dot(double3(-1.2e153, 5.5e153, 3.4e153), double3(6.1e154, -9.2e154, -2.7e154)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void dot_double4()
         {
             TestUtils.AreEqual(68.57, dot(double4(1.2, 5.5, 3.4, 4.9), double4(6.1, 9.2, 2.7, 0.3)), 8, false);
@@ -1653,7 +1653,7 @@ public static void dot_double4()
             TestUtils.AreEqual(double.NegativeInfinity, dot(double4(-1.2e153, 5.5e153, 3.4e153, -4.9e153), double4(6.1e154, -9.2e154, -2.7e154, 3e153)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmin_int2()
         {
             TestUtils.AreEqual(100, cmin(int2(100, 200)));
@@ -1664,7 +1664,7 @@ public static void cmin_int2()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmin_int3()
         {
             TestUtils.AreEqual(100, cmin(int3(100, 200, 300)));
@@ -1675,7 +1675,7 @@ public static void cmin_int3()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmin_int4()
         {
             TestUtils.AreEqual(100, cmin(int4(100, 200, 300, 400)));
@@ -1685,7 +1685,7 @@ public static void cmin_int4()
             TestUtils.AreEqual(int.MinValue, cmin(int4(int.MaxValue, int.MinValue, 0, 19)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmin_uint2()
         {
             TestUtils.AreEqual(100u, cmin(uint2(100u, 200u)));
@@ -1694,7 +1694,7 @@ public static void cmin_uint2()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmin_uint3()
         {
             TestUtils.AreEqual(100u, cmin(uint3(100u, 200u, 300u)));
@@ -1703,7 +1703,7 @@ public static void cmin_uint3()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmin_uint4()
         {
             TestUtils.AreEqual(100u, cmin(uint4(100u, 200u, 300u, 400u)));
@@ -1711,7 +1711,7 @@ public static void cmin_uint4()
             TestUtils.AreEqual(uint.MinValue, cmin(uint4(19u, uint.MinValue, uint.MaxValue, 7u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmin_float2()
         {
             TestUtils.AreEqual(-0.5f, cmin(float2(5.2f, -0.5f)));
@@ -1730,7 +1730,7 @@ public static void cmin_float2()
             TestUtils.AreEqual(float.NegativeInfinity, cmin(float2(float.NaN, float.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmin_float3()
         {
             TestUtils.AreEqual(-1.2f, cmin(float3(5.2f, -0.5f, -1.2f)));
@@ -1750,7 +1750,7 @@ public static void cmin_float3()
             TestUtils.AreEqual(float.NegativeInfinity, cmin(float3(float.NaN, float.NaN, float.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmin_float4()
         {
             TestUtils.AreEqual(-1.2f, cmin(float4(5.2f, -0.5f, -1.2f, 2.3f)));
@@ -1773,7 +1773,7 @@ public static void cmin_float4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmin_double2()
         {
             TestUtils.AreEqual(-0.5, cmin(double2(5.2, -0.5)));
@@ -1793,7 +1793,7 @@ public static void cmin_double2()
             TestUtils.AreEqual(double.NegativeInfinity, cmin(double2(double.NaN, double.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmin_double3()
         {
             TestUtils.AreEqual(-1.2, cmin(double3(5.2, -0.5, -1.2)));
@@ -1814,7 +1814,7 @@ public static void cmin_double3()
             TestUtils.AreEqual(double.NegativeInfinity, cmin(double3(double.NaN, double.NaN, double.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmin_double4()
         {
             TestUtils.AreEqual(-1.2, cmin(double4(5.2, -0.5, -1.2, 2.3)));
@@ -1839,7 +1839,7 @@ public static void cmin_double4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmax_int2()
         {
             TestUtils.AreEqual(200, cmax(int2(100, 200)));
@@ -1850,7 +1850,7 @@ public static void cmax_int2()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmax_int3()
         {
             TestUtils.AreEqual(300, cmax(int3(100, 200, 300)));
@@ -1861,7 +1861,7 @@ public static void cmax_int3()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmax_int4()
         {
             TestUtils.AreEqual(400, cmax(int4(100, 200, 300, 400)));
@@ -1871,7 +1871,7 @@ public static void cmax_int4()
             TestUtils.AreEqual(int.MaxValue, cmax(int4(int.MaxValue, int.MinValue, 0, 19)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmax_uint2()
         {
             TestUtils.AreEqual(200u, cmax(uint2(100u, 200u)));
@@ -1880,7 +1880,7 @@ public static void cmax_uint2()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmax_uint3()
         {
             TestUtils.AreEqual(300u, cmax(uint3(100u, 200u, 300u)));
@@ -1889,7 +1889,7 @@ public static void cmax_uint3()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmax_uint4()
         {
             TestUtils.AreEqual(400u, cmax(uint4(100u, 200u, 300u, 400u)));
@@ -1897,7 +1897,7 @@ public static void cmax_uint4()
             TestUtils.AreEqual(uint.MaxValue, cmax(uint4(19u, uint.MinValue, uint.MaxValue, 7u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmax_float2()
         {
             TestUtils.AreEqual(5.2f, cmax(float2(5.2f, -0.5f)));
@@ -1916,7 +1916,7 @@ public static void cmax_float2()
             TestUtils.AreEqual(float.NegativeInfinity, cmax(float2(float.NaN, float.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmax_float3()
         {
             TestUtils.AreEqual(5.2f, cmax(float3(5.2f, -0.5f, -1.2f)));
@@ -1936,7 +1936,7 @@ public static void cmax_float3()
             TestUtils.AreEqual(float.NegativeInfinity, cmax(float3(float.NaN, float.NaN, float.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmax_float4()
         {
             TestUtils.AreEqual(5.2f, cmax(float4(5.2f, -0.5f, -1.2f, 2.3f)));
@@ -1959,7 +1959,7 @@ public static void cmax_float4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmax_double2()
         {
             TestUtils.AreEqual(5.2, cmax(double2(5.2, -0.5)));
@@ -1979,7 +1979,7 @@ public static void cmax_double2()
             TestUtils.AreEqual(double.NegativeInfinity, cmax(double2(double.NaN, double.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmax_double3()
         {
             TestUtils.AreEqual(5.2, cmax(double3(5.2, -0.5, -1.2)));
@@ -2000,7 +2000,7 @@ public static void cmax_double3()
             TestUtils.AreEqual(double.NegativeInfinity, cmax(double3(double.NaN, double.NaN, double.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cmax_double4()
         {
             TestUtils.AreEqual(5.2, cmax(double4(5.2, -0.5, -1.2, 2.3)));
@@ -2024,7 +2024,7 @@ public static void cmax_double4()
             TestUtils.AreEqual(double.NegativeInfinity, cmax(double4(double.NaN, double.NaN, double.NaN, double.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void csum_int2()
         {
             TestUtils.AreEqual(300, csum(int2(100, 200)));
@@ -2035,7 +2035,7 @@ public static void csum_int2()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void csum_int3()
         {
             TestUtils.AreEqual(600, csum(int3(100, 200, 300)));
@@ -2046,7 +2046,7 @@ public static void csum_int3()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void csum_int4()
         {
             TestUtils.AreEqual(1000, csum(int4(100, 200, 300, 400)));
@@ -2056,7 +2056,7 @@ public static void csum_int4()
             TestUtils.AreEqual(-1, csum(int4(int.MaxValue, int.MinValue, 0, 0)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void csum_uint2()
         {
             TestUtils.AreEqual(300u, csum(uint2(100u, 200u)));
@@ -2064,7 +2064,7 @@ public static void csum_uint2()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void csum_uint3()
         {
             TestUtils.AreEqual(600u, csum(uint3(100u, 200u, 300u)));
@@ -2072,14 +2072,14 @@ public static void csum_uint3()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void csum_uint4()
         {
             TestUtils.AreEqual(1000u, csum(uint4(100u, 200u, 300u, 400u)));
             TestUtils.AreEqual(36u, csum(uint4(uint.MaxValue, 7u, 11u, 19u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void csum_float2()
         {
             TestUtils.AreEqual(0.7f, csum(float2(2.2f, -1.5f)), 4, false);
@@ -2102,7 +2102,7 @@ public static void csum_float2()
             TestUtils.AreEqual(float.NegativeInfinity, csum(float2(-1.0f, float.NegativeInfinity)), 0, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void csum_float3()
         {
             TestUtils.AreEqual(1.9f, csum(float3(2.2f, -1.5f, 1.2f)), 4, false);
@@ -2126,7 +2126,7 @@ public static void csum_float3()
             TestUtils.AreEqual(float.NegativeInfinity, csum(float3(-2.0f, 1.0f, float.NegativeInfinity)), 0, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void csum_float4()
         {
             TestUtils.AreEqual(1.2f, csum(float4(2.2f, -1.5f, 1.2f, -0.7f)), 4, false);
@@ -2153,7 +2153,7 @@ public static void csum_float4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void csum_double2()
         {
             TestUtils.AreEqual(0.7, csum(double2(2.2, -1.5)), 4, false);
@@ -2176,7 +2176,7 @@ public static void csum_double2()
             TestUtils.AreEqual(double.NegativeInfinity, csum(double2(-1.0, double.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void csum_double3()
         {
             TestUtils.AreEqual(1.9, csum(double3(2.2, -1.5, 1.2)), 4, false);
@@ -2200,7 +2200,7 @@ public static void csum_double3()
             TestUtils.AreEqual(double.NegativeInfinity, csum(double3(-2.0, 1.0, double.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void csum_double4()
         {
             TestUtils.AreEqual(1.2, csum(double4(2.2, -1.5, 1.2, -0.7)), 4, false);
@@ -2227,7 +2227,7 @@ public static void csum_double4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void any_bool2()
         {
             TestUtils.AreEqual(false, any(bool2(false, false)));
@@ -2236,7 +2236,7 @@ public static void any_bool2()
             TestUtils.AreEqual(true, any(bool2(true, true)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void any_bool3()
         {
             TestUtils.AreEqual(false, any(bool3(false, false, false)));
@@ -2250,7 +2250,7 @@ public static void any_bool3()
             TestUtils.AreEqual(true, any(bool3(true, true, true)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void any_bool4()
         {
             TestUtils.AreEqual(false, any(bool4(false, false, false, false)));
@@ -2274,7 +2274,7 @@ public static void any_bool4()
             TestUtils.AreEqual(true, any(bool4(true, true, true, true)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void any_int2()
         {
             TestUtils.AreEqual(false, any(int2(0, 0)));
@@ -2284,7 +2284,7 @@ public static void any_int2()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void any_int3()
         {
             TestUtils.AreEqual(false, any(int3(0, 0, 0)));
@@ -2298,7 +2298,7 @@ public static void any_int3()
             TestUtils.AreEqual(true, any(int3(-121, 100, 322)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void any_int4()
         {
             TestUtils.AreEqual(false, any(int4(0, 0, 0, 0)));
@@ -2323,7 +2323,7 @@ public static void any_int4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void any_uint2()
         {
             TestUtils.AreEqual(false, any(uint2(0u, 0u)));
@@ -2333,7 +2333,7 @@ public static void any_uint2()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void any_uint3()
         {
             TestUtils.AreEqual(false, any(uint3(0u, 0u, 0u)));
@@ -2347,7 +2347,7 @@ public static void any_uint3()
             TestUtils.AreEqual(true, any(uint3(121u, 100u, 322u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void any_uint4()
         {
             TestUtils.AreEqual(false, any(uint4(0u, 0u, 0u, 0u)));
@@ -2372,7 +2372,7 @@ public static void any_uint4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void any_float2()
         {
             //TestUtils.AreEqual(true, any(float2(0, float.NaN)));    // TODO: doesn't work with burst
@@ -2384,7 +2384,7 @@ public static void any_float2()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void any_float3()
         {
             //TestUtils.AreEqual(true, any(float3(0.0f, float.NaN, 0.0f)));    // TODO: doesn't work with burst
@@ -2400,7 +2400,7 @@ public static void any_float3()
             TestUtils.AreEqual(true, any(float3(121.2f, 100.0f, -32.2f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void any_float4()
         {
             TestUtils.AreEqual(false, any(float4(0.0f, 0.0f, 0.0f, 0.0f)));
@@ -2424,7 +2424,7 @@ public static void any_float4()
             TestUtils.AreEqual(true, any(float4(55.0f, 66.0f, 5000.0f, 10000.2f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void any_double2()
         {
             //TestUtils.AreEqual(true, any(double2(0, double.NaN)));    // TODO: doesn't work with burst.
@@ -2436,7 +2436,7 @@ public static void any_double2()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void any_double3()
         {
             //TestUtils.AreEqual(true, any(double3(0.0, double.NaN, 0.0)));    // TODO: doesn't work with burst
@@ -2452,7 +2452,7 @@ public static void any_double3()
             TestUtils.AreEqual(true, any(double3(121.2, 100.0, -32.2)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void any_double4()
         {
             TestUtils.AreEqual(false, any(double4(0.0, 0.0, 0.0, 0.0)));
@@ -2477,7 +2477,7 @@ public static void any_double4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void all_bool2()
         {
             TestUtils.AreEqual(false, all(bool2(false, false)));
@@ -2486,7 +2486,7 @@ public static void all_bool2()
             TestUtils.AreEqual(true, all(bool2(true, true)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void all_bool3()
         {
             TestUtils.AreEqual(false, all(bool3(false, false, false)));
@@ -2500,7 +2500,7 @@ public static void all_bool3()
             TestUtils.AreEqual(true, all(bool3(true, true, true)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void all_bool4()
         {
             TestUtils.AreEqual(false, all(bool4(false, false, false, false)));
@@ -2524,7 +2524,7 @@ public static void all_bool4()
             TestUtils.AreEqual(true, all(bool4(true, true, true, true)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void all_int2()
         {
             TestUtils.AreEqual(false, all(int2(0, 0)));
@@ -2533,7 +2533,7 @@ public static void all_int2()
             TestUtils.AreEqual(true, all(int2(2, int.MinValue)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void all_int3()
         {
             TestUtils.AreEqual(false, all(int3(0, 0, 0)));
@@ -2547,7 +2547,7 @@ public static void all_int3()
             TestUtils.AreEqual(true, all(int3(-121, 100, 322)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void all_int4()
         {
             TestUtils.AreEqual(false, all(int4(0, 0, 0, 0)));
@@ -2572,7 +2572,7 @@ public static void all_int4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void all_uint2()
         {
             TestUtils.AreEqual(false, all(uint2(0u, 0u)));
@@ -2582,7 +2582,7 @@ public static void all_uint2()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void all_uint3()
         {
             TestUtils.AreEqual(false, all(uint3(0u, 0u, 0u)));
@@ -2596,7 +2596,7 @@ public static void all_uint3()
             TestUtils.AreEqual(true, all(uint3(121u, 100u, 322u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void all_uint4()
         {
             TestUtils.AreEqual(false, all(uint4(0u, 0u, 0u, 0u)));
@@ -2621,7 +2621,7 @@ public static void all_uint4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void all_float2()
         {
             TestUtils.AreEqual(true, all(float2(float.NaN, float.NaN)));
@@ -2633,7 +2633,7 @@ public static void all_float2()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void all_float3()
         {
             TestUtils.AreEqual(true, all(float3(float.NaN, float.NaN, float.NaN)));
@@ -2649,7 +2649,7 @@ public static void all_float3()
             TestUtils.AreEqual(true, all(float3(121.2f, 100.0f, -32.2f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void all_float4()
         {
             TestUtils.AreEqual(true, all(float4(float.NaN, float.NaN, float.NaN, float.NaN)));
@@ -2675,7 +2675,7 @@ public static void all_float4()
             TestUtils.AreEqual(true, all(float4(55.0f, 66.0f, 5000.0f, 10000.2f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void all_double2()
         {
             TestUtils.AreEqual(true, all(double2(double.NaN, double.NaN)));
@@ -2687,7 +2687,7 @@ public static void all_double2()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void all_double3()
         {
             TestUtils.AreEqual(true, all(double3(double.NaN, double.NaN, double.NaN)));
@@ -2703,7 +2703,7 @@ public static void all_double3()
             TestUtils.AreEqual(true, all(double3(121.2, 100.0, -32.2)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void all_double4()
         {
             TestUtils.AreEqual(true, all(double4(double.NaN, double.NaN, double.NaN, double.NaN)));
@@ -2730,7 +2730,7 @@ public static void all_double4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void length_float2()
         {
             TestUtils.AreEqual(0.0f, length(float2(0.0f, 0.0f)), 0, false);
@@ -2743,7 +2743,7 @@ public static void length_float2()
             TestUtils.AreEqual(double.PositiveInfinity, length(float2(-1.2e19f, -2.6e19f)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void length_float3()
         {
             TestUtils.AreEqual(0.0f, length(float3(0.0f, 0.0f, 0.0f)), 0, false);
@@ -2756,7 +2756,7 @@ public static void length_float3()
             TestUtils.AreEqual(float.PositiveInfinity, length(float3(-1.2e19f, -2.6e19f, 2.2e19f)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void length_float4()
         {
             TestUtils.AreEqual(0.0f, length(float4(0.0f, 0.0f, 0.0f, 0.0f)), 0, false);
@@ -2770,7 +2770,7 @@ public static void length_float4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void length_double2()
         {
             TestUtils.AreEqual(0.0, length(double2(0.0, 0.0)), 0, false);
@@ -2782,7 +2782,7 @@ public static void length_double2()
             TestUtils.AreEqual(2.86356421265527063e153, length(double2(-1.2e153, 2.6e153)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void length_double3()
         {
             TestUtils.AreEqual(0.0, length(double3(0.0, 0.0, 0.0)), 0, false);
@@ -2794,7 +2794,7 @@ public static void length_double3()
             TestUtils.AreEqual(3.6110940170535577e153, length(double3(-1.2e153, 2.6e153, 2.2e153)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void length_double4()
         {
             TestUtils.AreEqual(0.0, length(double4(0.0, 0.0, 0.0, 0.0)), 0, false);
@@ -2807,7 +2807,7 @@ public static void length_double4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lengthsq_float2()
         {
             TestUtils.AreEqual(0.0f, lengthsq(float2(0.0f, 0.0f)), 0, false);
@@ -2819,7 +2819,7 @@ public static void lengthsq_float2()
             TestUtils.AreEqual(8.2e36f, lengthsq(float2(-1.2e18f, 2.6e18f)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lengthsq_float3()
         {
             TestUtils.AreEqual(0.0f, lengthsq(float3(0.0f, 0.0f, 0.0f)), 0, false);
@@ -2832,7 +2832,7 @@ public static void lengthsq_float3()
             TestUtils.AreEqual(float.PositiveInfinity, lengthsq(float3(-1.2e19f, -2.6e19f, 2.2e19f)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lengthsq_float4()
         {
             TestUtils.AreEqual(0.0f, lengthsq(float4(0.0f, 0.0f, 0.0f, 0.0f)), 0, false);
@@ -2846,7 +2846,7 @@ public static void lengthsq_float4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lengthsq_double2()
         {
             TestUtils.AreEqual(0.0, lengthsq(double2(0.0, 0.0)), 0, false);
@@ -2859,7 +2859,7 @@ public static void lengthsq_double2()
             TestUtils.AreEqual(double.PositiveInfinity, lengthsq(double2(-1.2e154, -2.6e154)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lengthsq_double3()
         {
             TestUtils.AreEqual(0.0, lengthsq(double3(0.0, 0.0, 0.0)), 0, false);
@@ -2872,7 +2872,7 @@ public static void lengthsq_double3()
             TestUtils.AreEqual(double.PositiveInfinity, lengthsq(double3(-1.2e154, -2.6e154, 2.2e154)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lengthsq_double4()
         {
             TestUtils.AreEqual(0.0, lengthsq(double4(0.0, 0.0, 0.0, 0.0)), 0, false);
@@ -2888,7 +2888,7 @@ public static void lengthsq_double4()
 
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void distance_float2()
         {
             TestUtils.AreEqual(0.0f, distance(float2(1.3f, -2.4f), float2(1.3f, -2.4f)), 0, false);
@@ -2902,7 +2902,7 @@ public static void distance_float2()
             TestUtils.AreEqual(float.PositiveInfinity, distance(float2(1.3f, float.NegativeInfinity), float2(-5.3f, 4.3f)), 0, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void distance_float3()
         {
             TestUtils.AreEqual(0.0f, distance(float2(1.3f, -2.4f), float2(1.3f, -2.4f)), 0, false);
@@ -2916,7 +2916,7 @@ public static void distance_float3()
             TestUtils.AreEqual(float.PositiveInfinity, distance(float2(1.3f, float.NegativeInfinity), float2(-5.3f, 4.3f)), 0, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void distance_float4()
         {
             TestUtils.AreEqual(0.0, distance(float4(1.3f, -2.4f, 5.7f, 3.1f), float4(1.3f, -2.4f, 5.7f, 3.1f)), 0, false);
@@ -2931,7 +2931,7 @@ public static void distance_float4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void distance_double2()
         {
             TestUtils.AreEqual(0.0, distance(double2(1.3, -2.4), double2(1.3, -2.4)), 0, false);
@@ -2944,7 +2944,7 @@ public static void distance_double2()
             TestUtils.AreEqual(double.PositiveInfinity, distance(double2(1.3, -2.4), double2(-5.3, double.PositiveInfinity)), 0, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void distance_double3()
         {
             TestUtils.AreEqual(0.0, distance(double2(1.3, -2.4), double2(1.3, -2.4)), 0, false);
@@ -2957,7 +2957,7 @@ public static void distance_double3()
             TestUtils.AreEqual(double.PositiveInfinity, distance(double2(1.3, -2.4), double2(-5.3, double.PositiveInfinity)), 0, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void distance_double4()
         {
             TestUtils.AreEqual(0.0, distance(double4(1.3, -2.4, 5.7, 3.1), double4(1.3, -2.4, 5.7, 3.1)), 0, false);
@@ -2970,7 +2970,7 @@ public static void distance_double4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void distancesq_float2()
         {
             TestUtils.AreEqual(0.0f, distancesq(float2(1.3f, -2.4f), float2(1.3f, -2.4f)), 0, false);
@@ -2982,7 +2982,7 @@ public static void distancesq_float2()
             TestUtils.AreEqual(float.PositiveInfinity, distancesq(float2(1.3f, -2.4f), float2(-5.3f, float.PositiveInfinity)), 0, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void distancesq_float3()
         {
             TestUtils.AreEqual(0.0f, distancesq(float3(1.3f, -2.4f, 5.7f), float3(1.3f, -2.4f, 5.7f)), 0, false);
@@ -2995,7 +2995,7 @@ public static void distancesq_float3()
             TestUtils.AreEqual(float.PositiveInfinity, distancesq(float3(1.3f, -2.4f, 5.7f), float3(-5.3f, float.PositiveInfinity, 4.7f)), 0, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void distancesq_float4()
         {
             TestUtils.AreEqual(0.0f, distancesq(float4(1.3f, -2.4f, 5.7f, 3.1f), float4(1.3f, -2.4f, 5.7f, 3.1f)), 0, false);
@@ -3008,7 +3008,7 @@ public static void distancesq_float4()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void distancesq_double2()
         {
             TestUtils.AreEqual(0.0, distancesq(double2(1.3, -2.4), double2(1.3, -2.4)), 0, false);
@@ -3022,7 +3022,7 @@ public static void distancesq_double2()
             TestUtils.AreEqual(double.PositiveInfinity, distancesq(double2(1.3, double.NegativeInfinity), double2(-5.3, 4.3)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void distancesq_double3()
         {
             TestUtils.AreEqual(0.0, distancesq(double3(1.3, -2.4, 5.7), double3(1.3, -2.4, 5.7)), 0, false);
@@ -3036,7 +3036,7 @@ public static void distancesq_double3()
             TestUtils.AreEqual(double.PositiveInfinity, distancesq(double3(1.3, double.NegativeInfinity, 5.7), double3(-5.3, 4.3, 4.7)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void distancesq_double4()
         {
             TestUtils.AreEqual(0.0, distancesq(double4(1.3, -2.4, 5.7, 3.1), double4(1.3, -2.4, 5.7, 3.1)), 0, false);
@@ -3050,7 +3050,7 @@ public static void distancesq_double4()
             TestUtils.AreEqual(double.PositiveInfinity, distancesq(double4(1.3, double.NegativeInfinity, 5.7, 3.1), double4(-5.3, 4.3, 4.7, 0.3)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void epsilon_float()
         {
             float next = asfloat(asuint(1.0f) + 1);
@@ -3059,7 +3059,7 @@ public static void epsilon_float()
             TestUtils.IsTrue(Single.Epsilon != EPSILON);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void epsilon_double()
         {
             double next = asdouble(aslong(1.0) + 1);
@@ -3068,7 +3068,7 @@ public static void epsilon_double()
             TestUtils.IsTrue(Double.Epsilon != EPSILON_DBL);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void nan_float()
         {
             TestUtils.IsFalse(0.0f == NAN);
@@ -3093,7 +3093,7 @@ public static void nan_float()
             TestUtils.IsTrue(nan1 != nan2);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void nan_double()
         {
             TestUtils.IsFalse(0.0 == NAN_DBL);
@@ -3118,7 +3118,7 @@ public static void nan_double()
             TestUtils.IsTrue(nan1 != nan2);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void infinity_float()
         {
             TestUtils.IsTrue(-INFINITY != INFINITY);
@@ -3126,7 +3126,7 @@ public static void infinity_float()
             TestUtils.IsFalse(isfinite(INFINITY));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void infinity_double()
         {
             TestUtils.IsTrue(-INFINITY_DBL != INFINITY_DBL);
@@ -3134,7 +3134,7 @@ public static void infinity_double()
             TestUtils.IsFalse(isfinite(INFINITY_DBL));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void helper_axes()
         {
             TestUtils.AreEqual(float3(1.0f, 0.0f, 0.0f), right());
@@ -3145,7 +3145,7 @@ public static void helper_axes()
             TestUtils.AreEqual(float3(0.0f, 0.0f, -1.0f), back());
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void rcp_float_signed_zero()
         {
@@ -3153,21 +3153,21 @@ public static void rcp_float_signed_zero()
             TestUtils.AreEqual(TestUtils.SignedFloatZero(), rcp(float.NegativeInfinity));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void rcp_float2_signed_zero()
         {
             TestUtils.AreEqual(float2(float.NegativeInfinity, TestUtils.SignedFloatZero()), rcp(float2(TestUtils.SignedFloatZero(), float.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void rcp_float3_signed_zero()
         {
             TestUtils.AreEqual(float3(float.NegativeInfinity, TestUtils.SignedFloatZero(), float.NegativeInfinity), rcp(float3(TestUtils.SignedFloatZero(), float.NegativeInfinity, TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void rcp_float4_signed_zero()
         {
@@ -3175,7 +3175,7 @@ public static void rcp_float4_signed_zero()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void rcp_double_signed_zero()
         {
@@ -3183,28 +3183,28 @@ public static void rcp_double_signed_zero()
             TestUtils.AreEqual(TestUtils.SignedDoubleZero(), rcp(double.NegativeInfinity));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void rcp_double2_signed_zero()
         {
             TestUtils.AreEqual(double2(double.NegativeInfinity, TestUtils.SignedDoubleZero()), rcp(double2(TestUtils.SignedDoubleZero(), double.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void rcp_double3_signed_zero()
         {
             TestUtils.AreEqual(double3(double.NegativeInfinity, TestUtils.SignedDoubleZero(), double.NegativeInfinity), rcp(double3(TestUtils.SignedDoubleZero(), double.NegativeInfinity, TestUtils.SignedDoubleZero())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void rcp_double4_signed_zero()
         {
             TestUtils.AreEqual(double4(double.NegativeInfinity, TestUtils.SignedDoubleZero(), double.NegativeInfinity, TestUtils.SignedDoubleZero()), rcp(double4(TestUtils.SignedDoubleZero(), double.NegativeInfinity, TestUtils.SignedDoubleZero(), double.NegativeInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         unsafe public static void compress_test()
         {
             int4 value = int4(0x12345678, 0x2468ACE0, 0x369BE147, 0x48C059D1);
@@ -3250,7 +3250,7 @@ unsafe public static void compress_test()
             }
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         unsafe public static void compress_uint4_test()
         {
             uint4 value = uint4(0x12345678u, 0x2468ACE0u, 0x369BE147u, 0x48C059D1u);
@@ -3296,7 +3296,7 @@ unsafe public static void compress_uint4_test()
             }
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         unsafe public static void compress_float4_test()
         {
             float4 value = float4(float.PositiveInfinity,  EPSILON, PI, -0.25f);
@@ -3342,7 +3342,7 @@ unsafe public static void compress_float4_test()
             }
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void square_float()
         {
             TestUtils.AreEqual(0.0f, math.square(0.0f));
@@ -3370,7 +3370,7 @@ public static void square_float()
             TestUtils.AreEqual(float.PositiveInfinity, math.square(-18446744073709551616.0f));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void square_float2()
         {
             TestUtils.AreEqual(new float2(0.0f), math.square(new float2(0.0f)));
@@ -3401,7 +3401,7 @@ public static void square_float2()
             TestUtils.AreEqual(new float2(0.272176146507263183594f, 96307.6015625f), math.square(new float2(0.521705031394958496094f, -310.33465576171875f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void square_float3()
         {
             TestUtils.AreEqual(new float3(0.0f), math.square(new float3(0.0f)));
@@ -3432,7 +3432,7 @@ public static void square_float3()
             TestUtils.AreEqual(new float3(0.272176146507263183594f, 96307.6015625f, 5591.6337890625f), math.square(new float3(0.521705031394958496094f, -310.33465576171875f, -74.77722930908203125f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void square_float4()
         {
             TestUtils.AreEqual(new float4(0.0f), math.square(new float4(0.0f)));
@@ -3463,7 +3463,7 @@ public static void square_float4()
             TestUtils.AreEqual(new float4(0.272176146507263183594f, 96307.6015625f, 5591.6337890625f, 152764.28125f), math.square(new float4(0.521705031394958496094f, -310.33465576171875f, -74.77722930908203125f, 390.8507080078125f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void square_double()
         {
             TestUtils.AreEqual(0.0, math.square(0.0));
@@ -3491,7 +3491,7 @@ public static void square_double()
             TestUtils.AreEqual(double.PositiveInfinity, math.square(-1.34078079299425970996e+154));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void square_double2()
         {
             TestUtils.AreEqual(new double2(0.0), math.square(new double2(0.0)));
@@ -3522,7 +3522,7 @@ public static void square_double2()
             TestUtils.AreEqual(new double2(0.272176139782814630053, 96307.5985667444765568), math.square(new double2(0.521705031394958496094, -310.33465576171875)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void square_double3()
         {
             TestUtils.AreEqual(new double3(0.0), math.square(new double3(0.0)));
@@ -3553,7 +3553,7 @@ public static void square_double3()
             TestUtils.AreEqual(new double3(0.272176139782814630053, 96307.5985667444765568, 5591.63402314303675666), math.square(new double3(0.521705031394958496094, -310.33465576171875, -74.77722930908203125)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void square_double4()
         {
             TestUtils.AreEqual(new double4(0.0), math.square(new double4(0.0)));
@@ -3584,7 +3584,7 @@ public static void square_double4()
             TestUtils.AreEqual(new double4(0.272176139782814630053, 96307.5985667444765568 /*96307.5985667444765568*/, 5591.63402314303675666 /*5591.6337890625*/, 152764.275950208306313 /*152764.28125*/), math.square(new double4(0.521705031394958496094, -310.33465576171875, -74.77722930908203125, 390.8507080078125)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void square_int()
         {
             TestUtils.AreEqual(0, math.square(0));
@@ -3612,7 +3612,7 @@ public static void square_int()
             TestUtils.AreEqual(0, math.square(-2147483648));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void square_int2()
         {
             TestUtils.AreEqual(new int2(0), math.square(new int2(0)));
@@ -3643,7 +3643,7 @@ public static void square_int2()
             TestUtils.AreEqual(new int2(2121580241, -685235535), math.square(new int2(-831443639, 1415191751)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void square_int3()
         {
             TestUtils.AreEqual(new int3(0), math.square(new int3(0)));
@@ -3674,7 +3674,7 @@ public static void square_int3()
             TestUtils.AreEqual(new int3(2121580241, -685235535, 468048505), math.square(new int3(-831443639, 1415191751, -178100469)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void square_int4()
         {
             TestUtils.AreEqual(new int4(0), math.square(new int4(0)));
@@ -3705,7 +3705,7 @@ public static void square_int4()
             TestUtils.AreEqual(new int4(2121580241, -685235535, 468048505, -1902728316), math.square(new int4(-831443639, 1415191751, -178100469, 1331775970)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void square_uint()
         {
             TestUtils.AreEqual(0u, math.square(0u));
@@ -3723,7 +3723,7 @@ public static void square_uint()
             TestUtils.AreEqual(2356482048u, math.square(123456u));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void square_uint2()
         {
             TestUtils.AreEqual(new uint2(0u), math.square(new uint2(0u)));
@@ -3744,7 +3744,7 @@ public static void square_uint2()
             TestUtils.AreEqual(new uint2(3982663844u, 503153673u), math.square(new uint2(779359642u, 2488899075u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void square_uint3()
         {
             TestUtils.AreEqual(new uint3(0u), math.square(new uint3(0u)));
@@ -3765,7 +3765,7 @@ public static void square_uint3()
             TestUtils.AreEqual(new uint3(3982663844u, 503153673u, 4101817232u), math.square(new uint3(779359642u, 2488899075u, 407772844u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void square_uint4()
         {
             TestUtils.AreEqual(new uint4(0u), math.square(new uint4(0u)));
@@ -3809,7 +3809,7 @@ static double OrthonormalBasisSquaredError(double3 v1, double3 v2, double3 v3)
         // "Building an Orthonormal Basis, Revisited" table 1.
         private const double kOrthonormalBasisSqErrorTolerance = 1.04e-7d;
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void orthonormal_basis_float()
         {
             var random = new Random(8189782u);
@@ -3824,7 +3824,7 @@ public static void orthonormal_basis_float()
             }
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void orthonormal_basis_double()
         {
             var random = new Random(99917872u);
@@ -3839,7 +3839,7 @@ public static void orthonormal_basis_double()
             }
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void chgsign_float()
         {
             float c = chgsign(1f, -1f);
@@ -3901,7 +3901,7 @@ public static void chgsign_float()
             TestUtils.AreEqual(asuint(TestUtils.SignedFloatZero()), asuint(c));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void chgsign_float2()
         {
             float2 c = chgsign(float2(1f, -2f), float2(-1f, 23.548f));
@@ -3936,7 +3936,7 @@ public static void chgsign_float2()
             TestUtils.AreEqual(asuint(math.float2(TestUtils.SignedFloatZero())), asuint(c));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void chgsign_float3()
         {
             float3 c = chgsign(float3(1f, -2f, 3f), float3(-1f, 23.548f, -0f));
@@ -3971,7 +3971,7 @@ public static void chgsign_float3()
             TestUtils.AreEqual(asuint(math.float3(TestUtils.SignedFloatZero())), asuint(c));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void chgsign_float4()
         {
             float4 c = chgsign(float4(1f, 2f, 3f, -4f), float4(-1f, 0f, -0f, -23.56f));
@@ -4006,7 +4006,7 @@ public static void chgsign_float4()
             TestUtils.AreEqual(asuint(math.float4(TestUtils.SignedFloatZero())), asuint(c));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static unsafe void quaternion_to_euler()
         {
             const float epsilon = 0.0045f;
@@ -4079,7 +4079,7 @@ static quaternion TestRefEulerToQuat(float3 angle, math.RotationOrder order)
             }
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mulScale()
         {
             var tolerance = 1e-5f;
@@ -4101,7 +4101,7 @@ public static void mulScale()
             TestUtils.AreEqual(expected, actual, tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void scaleMul()
         {
             var tolerance = 1e-5f;
@@ -4123,7 +4123,7 @@ public static void scaleMul()
             TestUtils.AreEqual(expected, actual, tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void piDoubleConstants()
         {
             var expectedPi = 3.141592653589793116;
@@ -4133,7 +4133,7 @@ public static void piDoubleConstants()
             TestUtils.AreEqual(expectedPi * 2.0, TAU_DBL);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void piSingleConstants()
         {
             var expectedPi = 3.141592653589793116f;
@@ -4143,7 +4143,7 @@ public static void piSingleConstants()
             TestUtils.AreEqual(expectedPi * 2.0f, TAU);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void toDegreesConstants()
         {
             TestUtils.AreEqual(360.0, PI2_DBL * TODEGREES_DBL);
@@ -4157,7 +4157,7 @@ public static void toDegreesConstants()
             TestUtils.AreEqual(90.0f, PIHALF * TODEGREES);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void toRadiansConstants()
         {
             TestUtils.AreEqual(PI2_DBL, 360.0 * TORADIANS_DBL);
@@ -4171,7 +4171,7 @@ public static void toRadiansConstants()
             TestUtils.AreEqual(PIHALF, 90.0f * TORADIANS);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void degreesConversionGivesSameResult()
         {
             int n = 360;
@@ -4184,7 +4184,7 @@ public static void degreesConversionGivesSameResult()
             }
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void radiansConversionGivesSameResult()
         {
             int n = 360;
diff --git a/src/Tests/Tests/Shared/TestMath.gen.cs b/src/Tests/Tests/Shared/TestMath.gen.cs
index 3a803b97..1a8e3253 100644
--- a/src/Tests/Tests/Shared/TestMath.gen.cs
+++ b/src/Tests/Tests/Shared/TestMath.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public partial class TestMath
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void abs_int()
         {
             TestUtils.AreEqual(0, abs(0));
@@ -25,7 +25,7 @@ public static void abs_int()
             TestUtils.AreEqual(-2147483648, abs(-2147483648));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void abs_int2()
         {
             TestUtils.AreEqual(int2(0, 7), abs(int2(0, -7)));
@@ -33,21 +33,21 @@ public static void abs_int2()
             TestUtils.AreEqual(int2(-2147483648, -2147483648), abs(int2(-2147483648, -2147483648)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void abs_int3()
         {
             TestUtils.AreEqual(int3(0, 7, 11), abs(int3(0, -7, 11)));
             TestUtils.AreEqual(int3(2147483647, -2147483648, -2147483648), abs(int3(-2147483647, -2147483648, -2147483648)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void abs_int4()
         {
             TestUtils.AreEqual(int4(0, 7, 11, 2147483647), abs(int4(0, -7, 11, -2147483647)));
             TestUtils.AreEqual(int4(-2147483648, -2147483648, -2147483648, -2147483648), abs(int4(-2147483648, -2147483648, -2147483648, -2147483648)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void abs_float()
         {
             TestUtils.AreEqual(0f, abs(0f));
@@ -57,7 +57,7 @@ public static void abs_float()
             TestUtils.AreEqual(float.PositiveInfinity, abs(float.PositiveInfinity));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void abs_float2()
         {
             TestUtils.AreEqual(float2(0f, 1.1f), abs(float2(0f, -1.1f)));
@@ -65,21 +65,21 @@ public static void abs_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), abs(float2(float.PositiveInfinity, float.PositiveInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void abs_float3()
         {
             TestUtils.AreEqual(float3(0f, 1.1f, 2.2f), abs(float3(0f, -1.1f, 2.2f)));
             TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), abs(float3(float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void abs_float4()
         {
             TestUtils.AreEqual(float4(0f, 1.1f, 2.2f, float.PositiveInfinity), abs(float4(0f, -1.1f, 2.2f, float.NegativeInfinity)));
             TestUtils.AreEqual(float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), abs(float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void abs_double()
         {
             TestUtils.AreEqual(0.0, abs(0.0));
@@ -89,7 +89,7 @@ public static void abs_double()
             TestUtils.AreEqual(double.PositiveInfinity, abs(double.PositiveInfinity));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void abs_double2()
         {
             TestUtils.AreEqual(double2(0.0, 1.1), abs(double2(0.0, -1.1)));
@@ -97,21 +97,21 @@ public static void abs_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), abs(double2(double.PositiveInfinity, double.PositiveInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void abs_double3()
         {
             TestUtils.AreEqual(double3(0.0, 1.1, 2.2), abs(double3(0.0, -1.1, 2.2)));
             TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), abs(double3(double.NegativeInfinity, double.PositiveInfinity, double.PositiveInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void abs_double4()
         {
             TestUtils.AreEqual(double4(0.0, 1.1, 2.2, double.PositiveInfinity), abs(double4(0.0, -1.1, 2.2, double.NegativeInfinity)));
             TestUtils.AreEqual(double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), abs(double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isfinite_float()
         {
             TestUtils.AreEqual(false, isfinite(TestUtils.SignedFloatQNaN()));
@@ -125,7 +125,7 @@ public static void isfinite_float()
             TestUtils.AreEqual(false, isfinite(TestUtils.UnsignedFloatQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isfinite_float2()
         {
             TestUtils.AreEqual(bool2(false, false), isfinite(float2(TestUtils.SignedFloatQNaN(), float.NegativeInfinity)));
@@ -135,7 +135,7 @@ public static void isfinite_float2()
             TestUtils.AreEqual(bool2(false, false), isfinite(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isfinite_float3()
         {
             TestUtils.AreEqual(bool3(false, false, true), isfinite(float3(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue)));
@@ -143,7 +143,7 @@ public static void isfinite_float3()
             TestUtils.AreEqual(bool3(true, false, false), isfinite(float3(float.MaxValue, float.PositiveInfinity, TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isfinite_float4()
         {
             TestUtils.AreEqual(bool4(false, false, true, true), isfinite(float4(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue, -1f)));
@@ -151,7 +151,7 @@ public static void isfinite_float4()
             TestUtils.AreEqual(bool4(false, false, false, false), isfinite(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isfinite_double()
         {
             TestUtils.AreEqual(false, isfinite(TestUtils.SignedDoubleQNaN()));
@@ -165,7 +165,7 @@ public static void isfinite_double()
             TestUtils.AreEqual(false, isfinite(TestUtils.UnsignedDoubleQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isfinite_double2()
         {
             TestUtils.AreEqual(bool2(false, false), isfinite(double2(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity)));
@@ -175,7 +175,7 @@ public static void isfinite_double2()
             TestUtils.AreEqual(bool2(false, false), isfinite(double2(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isfinite_double3()
         {
             TestUtils.AreEqual(bool3(false, false, true), isfinite(double3(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue)));
@@ -183,7 +183,7 @@ public static void isfinite_double3()
             TestUtils.AreEqual(bool3(true, false, false), isfinite(double3(double.MaxValue, double.PositiveInfinity, TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isfinite_double4()
         {
             TestUtils.AreEqual(bool4(false, false, true, true), isfinite(double4(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue, -1.0)));
@@ -191,7 +191,7 @@ public static void isfinite_double4()
             TestUtils.AreEqual(bool4(false, false, false, false), isfinite(double4(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isinf_float()
         {
             TestUtils.AreEqual(false, isinf(TestUtils.SignedFloatQNaN()));
@@ -205,7 +205,7 @@ public static void isinf_float()
             TestUtils.AreEqual(false, isinf(TestUtils.UnsignedFloatQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isinf_float2()
         {
             TestUtils.AreEqual(bool2(false, true), isinf(float2(TestUtils.SignedFloatQNaN(), float.NegativeInfinity)));
@@ -215,7 +215,7 @@ public static void isinf_float2()
             TestUtils.AreEqual(bool2(false, false), isinf(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isinf_float3()
         {
             TestUtils.AreEqual(bool3(false, true, false), isinf(float3(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue)));
@@ -223,7 +223,7 @@ public static void isinf_float3()
             TestUtils.AreEqual(bool3(false, true, false), isinf(float3(float.MaxValue, float.PositiveInfinity, TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isinf_float4()
         {
             TestUtils.AreEqual(bool4(false, true, false, false), isinf(float4(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue, -1f)));
@@ -231,7 +231,7 @@ public static void isinf_float4()
             TestUtils.AreEqual(bool4(false, false, false, false), isinf(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isinf_double()
         {
             TestUtils.AreEqual(false, isinf(TestUtils.SignedDoubleQNaN()));
@@ -245,7 +245,7 @@ public static void isinf_double()
             TestUtils.AreEqual(false, isinf(TestUtils.UnsignedDoubleQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isinf_double2()
         {
             TestUtils.AreEqual(bool2(false, true), isinf(double2(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity)));
@@ -255,7 +255,7 @@ public static void isinf_double2()
             TestUtils.AreEqual(bool2(false, false), isinf(double2(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isinf_double3()
         {
             TestUtils.AreEqual(bool3(false, true, false), isinf(double3(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue)));
@@ -263,7 +263,7 @@ public static void isinf_double3()
             TestUtils.AreEqual(bool3(false, true, false), isinf(double3(double.MaxValue, double.PositiveInfinity, TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isinf_double4()
         {
             TestUtils.AreEqual(bool4(false, true, false, false), isinf(double4(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue, -1.0)));
@@ -271,7 +271,7 @@ public static void isinf_double4()
             TestUtils.AreEqual(bool4(false, false, false, false), isinf(double4(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isnan_float()
         {
             TestUtils.AreEqual(true, isnan(TestUtils.SignedFloatQNaN()));
@@ -285,7 +285,7 @@ public static void isnan_float()
             TestUtils.AreEqual(true, isnan(TestUtils.UnsignedFloatQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isnan_float2()
         {
             TestUtils.AreEqual(bool2(true, false), isnan(float2(TestUtils.SignedFloatQNaN(), float.NegativeInfinity)));
@@ -295,7 +295,7 @@ public static void isnan_float2()
             TestUtils.AreEqual(bool2(true, true), isnan(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isnan_float3()
         {
             TestUtils.AreEqual(bool3(true, false, false), isnan(float3(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue)));
@@ -303,7 +303,7 @@ public static void isnan_float3()
             TestUtils.AreEqual(bool3(false, false, true), isnan(float3(float.MaxValue, float.PositiveInfinity, TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isnan_float4()
         {
             TestUtils.AreEqual(bool4(true, false, false, false), isnan(float4(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue, -1f)));
@@ -311,7 +311,7 @@ public static void isnan_float4()
             TestUtils.AreEqual(bool4(true, true, true, true), isnan(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isnan_double()
         {
             TestUtils.AreEqual(true, isnan(TestUtils.SignedDoubleQNaN()));
@@ -325,7 +325,7 @@ public static void isnan_double()
             TestUtils.AreEqual(true, isnan(TestUtils.UnsignedDoubleQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isnan_double2()
         {
             TestUtils.AreEqual(bool2(true, false), isnan(double2(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity)));
@@ -335,7 +335,7 @@ public static void isnan_double2()
             TestUtils.AreEqual(bool2(true, true), isnan(double2(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isnan_double3()
         {
             TestUtils.AreEqual(bool3(true, false, false), isnan(double3(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue)));
@@ -343,7 +343,7 @@ public static void isnan_double3()
             TestUtils.AreEqual(bool3(false, false, true), isnan(double3(double.MaxValue, double.PositiveInfinity, TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void isnan_double4()
         {
             TestUtils.AreEqual(bool4(true, false, false, false), isnan(double4(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue, -1.0)));
@@ -351,7 +351,7 @@ public static void isnan_double4()
             TestUtils.AreEqual(bool4(true, true, true, true), isnan(double4(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sin_float()
         {
             TestUtils.AreEqual(0.3499935f, sin(-1000000f), 1, false);
@@ -364,7 +364,7 @@ public static void sin_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), sin(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sin_float2()
         {
             TestUtils.AreEqual(float2(0.3499935f, -0.9320391f), sin(float2(-1000000f, -1.2f)), 1, false);
@@ -373,7 +373,7 @@ public static void sin_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), sin(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sin_float3()
         {
             TestUtils.AreEqual(float3(0.3499935f, -0.9320391f, 0f), sin(float3(-1000000f, -1.2f, 0f)), 1, false);
@@ -381,14 +381,14 @@ public static void sin_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), sin(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sin_float4()
         {
             TestUtils.AreEqual(float4(0.3499935f, -0.9320391f, 0f, 0.9320391f), sin(float4(-1000000f, -1.2f, 0f, 1.2f)), 1, false);
             TestUtils.AreEqual(float4(-0.3499935f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), sin(float4(1000000f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sin_double()
         {
             TestUtils.AreEqual(0.34999350217129294, sin(-1000000.0), 32, false);
@@ -401,7 +401,7 @@ public static void sin_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), sin(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sin_double2()
         {
             TestUtils.AreEqual(double2(0.34999350217129294, -0.9320390859672264), sin(double2(-1000000.0, -1.2)), 32, false);
@@ -410,7 +410,7 @@ public static void sin_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), sin(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sin_double3()
         {
             TestUtils.AreEqual(double3(0.34999350217129294, -0.9320390859672264, 0.0), sin(double3(-1000000.0, -1.2, 0.0)), 32, false);
@@ -418,14 +418,14 @@ public static void sin_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), sin(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sin_double4()
         {
             TestUtils.AreEqual(double4(0.34999350217129294, -0.9320390859672264, 0.0, 0.9320390859672264), sin(double4(-1000000.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(-0.34999350217129294, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), sin(double4(1000000.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cos_float()
         {
             TestUtils.AreEqual(0.936752141f, cos(-1000000f), 8, false);
@@ -438,7 +438,7 @@ public static void cos_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), cos(float.PositiveInfinity), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cos_float2()
         {
             TestUtils.AreEqual(float2(0.936752141f, 0.362357765f), cos(float2(-1000000f, -1.2f)), 8, false);
@@ -447,7 +447,7 @@ public static void cos_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), cos(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cos_float3()
         {
             TestUtils.AreEqual(float3(0.936752141f, 0.362357765f, 1f), cos(float3(-1000000f, -1.2f, 0f)), 8, false);
@@ -455,14 +455,14 @@ public static void cos_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), cos(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cos_float4()
         {
             TestUtils.AreEqual(float4(0.936752141f, 0.362357765f, 1f, 0.362357765f), cos(float4(-1000000f, -1.2f, 0f, 1.2f)), 8, false);
             TestUtils.AreEqual(float4(0.936752141f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), cos(float4(1000000f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cos_double()
         {
             TestUtils.AreEqual(0.93675212753314474, cos(-1000000.0), 32, false);
@@ -475,7 +475,7 @@ public static void cos_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), cos(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cos_double2()
         {
             TestUtils.AreEqual(double2(0.93675212753314474, 0.36235775447667357), cos(double2(-1000000.0, -1.2)), 32, false);
@@ -484,7 +484,7 @@ public static void cos_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), cos(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cos_double3()
         {
             TestUtils.AreEqual(double3(0.93675212753314474, 0.36235775447667357, 1.0), cos(double3(-1000000.0, -1.2, 0.0)), 32, false);
@@ -492,14 +492,14 @@ public static void cos_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), cos(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cos_double4()
         {
             TestUtils.AreEqual(double4(0.93675212753314474, 0.36235775447667357, 1.0, 0.36235775447667357), cos(double4(-1000000.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(0.93675212753314474, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), cos(double4(1000000.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tan_float()
         {
             TestUtils.AreEqual(0.373624444f, tan(-1000000f), 1, false);
@@ -512,7 +512,7 @@ public static void tan_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), tan(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tan_float2()
         {
             TestUtils.AreEqual(float2(0.373624444f, -2.57215166f), tan(float2(-1000000f, -1.2f)), 1, false);
@@ -521,7 +521,7 @@ public static void tan_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), tan(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tan_float3()
         {
             TestUtils.AreEqual(float3(0.373624444f, -2.57215166f, 0f), tan(float3(-1000000f, -1.2f, 0f)), 1, false);
@@ -529,14 +529,14 @@ public static void tan_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), tan(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tan_float4()
         {
             TestUtils.AreEqual(float4(0.373624444f, -2.57215166f, 0f, 2.57215166f), tan(float4(-1000000f, -1.2f, 0f, 1.2f)), 1, false);
             TestUtils.AreEqual(float4(-0.373624444f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), tan(float4(1000000f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tan_double()
         {
             TestUtils.AreEqual(0.373624453987599, tan(-1000000.0), 32, false);
@@ -549,7 +549,7 @@ public static void tan_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), tan(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tan_double2()
         {
             TestUtils.AreEqual(double2(0.373624453987599, -2.57215162212632), tan(double2(-1000000.0, -1.2)), 32, false);
@@ -558,7 +558,7 @@ public static void tan_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), tan(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tan_double3()
         {
             TestUtils.AreEqual(double3(0.373624453987599, -2.57215162212632, 0.0), tan(double3(-1000000.0, -1.2, 0.0)), 32, false);
@@ -566,14 +566,14 @@ public static void tan_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), tan(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tan_double4()
         {
             TestUtils.AreEqual(double4(0.373624453987599, -2.57215162212632, 0.0, 2.57215162212632), tan(double4(-1000000.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(-0.373624453987599, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), tan(double4(1000000.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void atan_float()
         {
             TestUtils.AreEqual(-1.5707953f, atan(-1000000f), 1, false);
@@ -586,7 +586,7 @@ public static void atan_float()
             TestUtils.AreEqual(1.57079637f, atan(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void atan_float2()
         {
             TestUtils.AreEqual(float2(-1.5707953f, -0.876058042f), atan(float2(-1000000f, -1.2f)), 1, false);
@@ -595,7 +595,7 @@ public static void atan_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), 1.57079637f), atan(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void atan_float3()
         {
             TestUtils.AreEqual(float3(-1.5707953f, -0.876058042f, 0f), atan(float3(-1000000f, -1.2f, 0f)), 1, false);
@@ -603,14 +603,14 @@ public static void atan_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 1.57079637f, 1.57079637f), atan(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void atan_float4()
         {
             TestUtils.AreEqual(float4(-1.5707953f, -0.876058042f, 0f, 0.876058042f), atan(float4(-1000000f, -1.2f, 0f, 1.2f)), 1, false);
             TestUtils.AreEqual(float4(1.5707953f, -1.57079637f, TestUtils.SignedFloatQNaN(), 1.57079637f), atan(float4(1000000f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void atan_double()
         {
             TestUtils.AreEqual(-1.5707953267948971, atan(-1000000.0), 32, false);
@@ -623,7 +623,7 @@ public static void atan_double()
             TestUtils.AreEqual(1.570796326794897, atan(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void atan_double2()
         {
             TestUtils.AreEqual(double2(-1.5707953267948971, -0.87605805059819342), atan(double2(-1000000.0, -1.2)), 32, false);
@@ -632,7 +632,7 @@ public static void atan_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), 1.570796326794897), atan(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void atan_double3()
         {
             TestUtils.AreEqual(double3(-1.5707953267948971, -0.87605805059819342, 0.0), atan(double3(-1000000.0, -1.2, 0.0)), 32, false);
@@ -640,14 +640,14 @@ public static void atan_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 1.570796326794897, 1.570796326794897), atan(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void atan_double4()
         {
             TestUtils.AreEqual(double4(-1.5707953267948971, -0.87605805059819342, 0.0, 0.87605805059819342), atan(double4(-1000000.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(1.5707953267948971, -1.570796326794897, TestUtils.SignedDoubleQNaN(), 1.570796326794897), atan(double4(1000000.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void atan2_float()
         {
             TestUtils.AreEqual(0.9119903f, atan2(3.1f, 2.4f), 1, false);
@@ -664,7 +664,7 @@ public static void atan2_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), atan2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void atan2_float2()
         {
             TestUtils.AreEqual(float2(0.9119903f, 2.22960234f), atan2(float2(3.1f, 3.1f), float2(2.4f, -2.4f)), 1, false);
@@ -675,7 +675,7 @@ public static void atan2_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), atan2(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(1f, TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void atan2_float3()
         {
             TestUtils.AreEqual(float3(0.9119903f, 2.22960234f, -0.9119903f), atan2(float3(3.1f, 3.1f, -3.1f), float3(2.4f, -2.4f, 2.4f)), 1, false);
@@ -684,7 +684,7 @@ public static void atan2_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), atan2(float3(1f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), 1f, TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void atan2_float4()
         {
             TestUtils.AreEqual(float4(0.9119903f, 2.22960234f, -0.9119903f, -2.22960234f), atan2(float4(3.1f, 3.1f, -3.1f, -3.1f), float4(2.4f, -2.4f, 2.4f, -2.4f)), 1, false);
@@ -692,7 +692,7 @@ public static void atan2_float4()
             TestUtils.AreEqual(float4(1.57079637f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), atan2(float4(float.PositiveInfinity, 1f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(1f, TestUtils.SignedFloatQNaN(), 1f, TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void atan2_double()
         {
             TestUtils.AreEqual(0.91199029067742043, atan2(3.1, 2.4), 32, false);
@@ -709,7 +709,7 @@ public static void atan2_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), atan2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void atan2_double2()
         {
             TestUtils.AreEqual(double2(0.91199029067742043, 2.2296023629123729), atan2(double2(3.1, 3.1), double2(2.4, -2.4)), 32, false);
@@ -720,7 +720,7 @@ public static void atan2_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), atan2(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(1.0, TestUtils.SignedDoubleQNaN())), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void atan2_double3()
         {
             TestUtils.AreEqual(double3(0.91199029067742043, 2.2296023629123729, -0.91199029067742043), atan2(double3(3.1, 3.1, -3.1), double3(2.4, -2.4, 2.4)), 32, false);
@@ -729,7 +729,7 @@ public static void atan2_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), atan2(double3(1.0, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), 1.0, TestUtils.SignedDoubleQNaN())), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void atan2_double4()
         {
             TestUtils.AreEqual(double4(0.91199029067742043, 2.2296023629123729, -0.91199029067742043, -2.2296023629123729), atan2(double4(3.1, 3.1, -3.1, -3.1), double4(2.4, -2.4, 2.4, -2.4)), 32, false);
@@ -737,7 +737,7 @@ public static void atan2_double4()
             TestUtils.AreEqual(double4(1.5707963267948966, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), atan2(double4(double.PositiveInfinity, 1.0, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(1.0, TestUtils.SignedDoubleQNaN(), 1.0, TestUtils.SignedDoubleQNaN())), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sinh_float()
         {
             TestUtils.AreEqual(-3.62686038f, sinh(-2f), 1, false);
@@ -750,7 +750,7 @@ public static void sinh_float()
             TestUtils.AreEqual(float.PositiveInfinity, sinh(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sinh_float2()
         {
             TestUtils.AreEqual(float2(-3.62686038f, -1.5094614f), sinh(float2(-2f, -1.2f)), 1, false);
@@ -759,7 +759,7 @@ public static void sinh_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), sinh(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sinh_float3()
         {
             TestUtils.AreEqual(float3(-3.62686038f, -1.5094614f, 0f), sinh(float3(-2f, -1.2f, 0f)), 1, false);
@@ -767,14 +767,14 @@ public static void sinh_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), sinh(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sinh_float4()
         {
             TestUtils.AreEqual(float4(-3.62686038f, -1.5094614f, 0f, 1.5094614f), sinh(float4(-2f, -1.2f, 0f, 1.2f)), 1, false);
             TestUtils.AreEqual(float4(3.62686038f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity), sinh(float4(2f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sinh_double()
         {
             TestUtils.AreEqual(-3.6268604078470181, sinh(-2.0), 32, false);
@@ -787,7 +787,7 @@ public static void sinh_double()
             TestUtils.AreEqual(double.PositiveInfinity, sinh(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sinh_double2()
         {
             TestUtils.AreEqual(double2(-3.6268604078470181, -1.509461355412173), sinh(double2(-2.0, -1.2)), 32, false);
@@ -796,7 +796,7 @@ public static void sinh_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), sinh(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sinh_double3()
         {
             TestUtils.AreEqual(double3(-3.6268604078470181, -1.509461355412173, 0.0), sinh(double3(-2.0, -1.2, 0.0)), 32, false);
@@ -804,14 +804,14 @@ public static void sinh_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), sinh(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sinh_double4()
         {
             TestUtils.AreEqual(double4(-3.6268604078470181, -1.509461355412173, 0.0, 1.509461355412173), sinh(double4(-2.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(3.6268604078470181, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), sinh(double4(2.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cosh_float()
         {
             TestUtils.AreEqual(3.76219559f, cosh(-2f), 1, false);
@@ -824,7 +824,7 @@ public static void cosh_float()
             TestUtils.AreEqual(float.PositiveInfinity, cosh(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cosh_float2()
         {
             TestUtils.AreEqual(float2(3.76219559f, 1.81065559f), cosh(float2(-2f, -1.2f)), 1, false);
@@ -833,7 +833,7 @@ public static void cosh_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), cosh(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cosh_float3()
         {
             TestUtils.AreEqual(float3(3.76219559f, 1.81065559f, 1f), cosh(float3(-2f, -1.2f, 0f)), 1, false);
@@ -841,14 +841,14 @@ public static void cosh_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), cosh(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cosh_float4()
         {
             TestUtils.AreEqual(float4(3.76219559f, 1.81065559f, 1f, 1.81065559f), cosh(float4(-2f, -1.2f, 0f, 1.2f)), 1, false);
             TestUtils.AreEqual(float4(3.76219559f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity), cosh(float4(2f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cosh_double()
         {
             TestUtils.AreEqual(3.7621956910836314, cosh(-2.0), 32, false);
@@ -861,7 +861,7 @@ public static void cosh_double()
             TestUtils.AreEqual(double.PositiveInfinity, cosh(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cosh_double2()
         {
             TestUtils.AreEqual(double2(3.7621956910836314, 1.81065556732437), cosh(double2(-2.0, -1.2)), 32, false);
@@ -870,7 +870,7 @@ public static void cosh_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), cosh(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cosh_double3()
         {
             TestUtils.AreEqual(double3(3.7621956910836314, 1.81065556732437, 1.0), cosh(double3(-2.0, -1.2, 0.0)), 32, false);
@@ -878,14 +878,14 @@ public static void cosh_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), cosh(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void cosh_double4()
         {
             TestUtils.AreEqual(double4(3.7621956910836314, 1.81065556732437, 1.0, 1.81065556732437), cosh(double4(-2.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(3.7621956910836314, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), cosh(double4(2.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tanh_float()
         {
             TestUtils.AreEqual(-0.9640276f, tanh(-2f), 1, false);
@@ -898,7 +898,7 @@ public static void tanh_float()
             TestUtils.AreEqual(1f, tanh(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tanh_float2()
         {
             TestUtils.AreEqual(float2(-0.9640276f, -0.8336546f), tanh(float2(-2f, -1.2f)), 1, false);
@@ -907,7 +907,7 @@ public static void tanh_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), 1f), tanh(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tanh_float3()
         {
             TestUtils.AreEqual(float3(-0.9640276f, -0.8336546f, 0f), tanh(float3(-2f, -1.2f, 0f)), 1, false);
@@ -915,14 +915,14 @@ public static void tanh_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 1f, 1f), tanh(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tanh_float4()
         {
             TestUtils.AreEqual(float4(-0.9640276f, -0.8336546f, 0f, 0.8336546f), tanh(float4(-2f, -1.2f, 0f, 1.2f)), 1, false);
             TestUtils.AreEqual(float4(0.9640276f, -1f, TestUtils.SignedFloatQNaN(), 1f), tanh(float4(2f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tanh_double()
         {
             TestUtils.AreEqual(-0.9640275800758169, tanh(-2.0), 32, false);
@@ -935,7 +935,7 @@ public static void tanh_double()
             TestUtils.AreEqual(1.0, tanh(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tanh_double2()
         {
             TestUtils.AreEqual(double2(-0.9640275800758169, -0.83365460701215521), tanh(double2(-2.0, -1.2)), 32, false);
@@ -944,7 +944,7 @@ public static void tanh_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), 1.0), tanh(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tanh_double3()
         {
             TestUtils.AreEqual(double3(-0.9640275800758169, -0.83365460701215521, 0.0), tanh(double3(-2.0, -1.2, 0.0)), 32, false);
@@ -952,14 +952,14 @@ public static void tanh_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 1.0, 1.0), tanh(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void tanh_double4()
         {
             TestUtils.AreEqual(double4(-0.9640275800758169, -0.83365460701215521, 0.0, 0.83365460701215521), tanh(double4(-2.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(0.9640275800758169, -1.0, TestUtils.SignedDoubleQNaN(), 1.0), tanh(double4(2.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp_float()
         {
             TestUtils.AreEqual(4.539993E-05f, exp(-10f), 1, false);
@@ -971,7 +971,7 @@ public static void exp_float()
             TestUtils.AreEqual(float.PositiveInfinity, exp(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp_float2()
         {
             TestUtils.AreEqual(float2(4.539993E-05f, 0.301194221f), exp(float2(-10f, -1.2f)), 1, false);
@@ -980,7 +980,7 @@ public static void exp_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), exp(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp_float3()
         {
             TestUtils.AreEqual(float3(4.539993E-05f, 0.301194221f, 1f), exp(float3(-10f, -1.2f, 0f)), 1, false);
@@ -988,14 +988,14 @@ public static void exp_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), exp(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp_float4()
         {
             TestUtils.AreEqual(float4(4.539993E-05f, 0.301194221f, 1f, 3.320117f), exp(float4(-10f, -1.2f, 0f, 1.2f)), 1, false);
             TestUtils.AreEqual(float4(0f, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), exp(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp_double()
         {
             TestUtils.AreEqual(4.5399929762484847E-05, exp(-10.0), 32, false);
@@ -1007,7 +1007,7 @@ public static void exp_double()
             TestUtils.AreEqual(double.PositiveInfinity, exp(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp_double2()
         {
             TestUtils.AreEqual(double2(4.5399929762484847E-05, 0.30119421191220208), exp(double2(-10.0, -1.2)), 32, false);
@@ -1016,7 +1016,7 @@ public static void exp_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), exp(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp_double3()
         {
             TestUtils.AreEqual(double3(4.5399929762484847E-05, 0.30119421191220208, 1.0), exp(double3(-10.0, -1.2, 0.0)), 32, false);
@@ -1024,14 +1024,14 @@ public static void exp_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), exp(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp_double4()
         {
             TestUtils.AreEqual(double4(4.5399929762484847E-05, 0.30119421191220208, 1.0, 3.3201169227365477), exp(double4(-10.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(0.0, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), exp(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp2_float()
         {
             TestUtils.AreEqual(0.0009765625f, exp2(-10f), 1, false);
@@ -1043,7 +1043,7 @@ public static void exp2_float()
             TestUtils.AreEqual(float.PositiveInfinity, exp2(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp2_float2()
         {
             TestUtils.AreEqual(float2(0.0009765625f, 0.4352753f), exp2(float2(-10f, -1.2f)), 1, false);
@@ -1052,7 +1052,7 @@ public static void exp2_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), exp2(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp2_float3()
         {
             TestUtils.AreEqual(float3(0.0009765625f, 0.4352753f, 1f), exp2(float3(-10f, -1.2f, 0f)), 1, false);
@@ -1060,14 +1060,14 @@ public static void exp2_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), exp2(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp2_float4()
         {
             TestUtils.AreEqual(float4(0.0009765625f, 0.4352753f, 1f, 2.29739666f), exp2(float4(-10f, -1.2f, 0f, 1.2f)), 1, false);
             TestUtils.AreEqual(float4(0f, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), exp2(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp2_double()
         {
             TestUtils.AreEqual(0.0009765625, exp2(-10.0), 32, false);
@@ -1079,7 +1079,7 @@ public static void exp2_double()
             TestUtils.AreEqual(double.PositiveInfinity, exp2(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp2_double2()
         {
             TestUtils.AreEqual(double2(0.0009765625, 0.435275281648062), exp2(double2(-10.0, -1.2)), 32, false);
@@ -1088,7 +1088,7 @@ public static void exp2_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), exp2(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp2_double3()
         {
             TestUtils.AreEqual(double3(0.0009765625, 0.435275281648062, 1.0), exp2(double3(-10.0, -1.2, 0.0)), 32, false);
@@ -1096,14 +1096,14 @@ public static void exp2_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), exp2(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp2_double4()
         {
             TestUtils.AreEqual(double4(0.0009765625, 0.435275281648062, 1.0, 2.29739670999407), exp2(double4(-10.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(0.0, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), exp2(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp10_float()
         {
             TestUtils.AreEqual(1E-10f, exp10(-10f), 32, false);
@@ -1115,7 +1115,7 @@ public static void exp10_float()
             TestUtils.AreEqual(float.PositiveInfinity, exp10(float.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp10_float2()
         {
             TestUtils.AreEqual(float2(1E-10f, 0.06309573f), exp10(float2(-10f, -1.2f)), 32, false);
@@ -1124,7 +1124,7 @@ public static void exp10_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), exp10(float2(float.PositiveInfinity, float.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp10_float3()
         {
             TestUtils.AreEqual(float3(1E-10f, 0.06309573f, 1f), exp10(float3(-10f, -1.2f, 0f)), 32, false);
@@ -1132,14 +1132,14 @@ public static void exp10_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), exp10(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp10_float4()
         {
             TestUtils.AreEqual(float4(1E-10f, 0.06309573f, 1f, 15.8489323f), exp10(float4(-10f, -1.2f, 0f, 1.2f)), 32, false);
             TestUtils.AreEqual(float4(0f, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), exp10(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp10_double()
         {
             TestUtils.AreEqual(1E-10, exp10(-10.0), 32, false);
@@ -1151,7 +1151,7 @@ public static void exp10_double()
             TestUtils.AreEqual(double.PositiveInfinity, exp10(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp10_double2()
         {
             TestUtils.AreEqual(double2(1E-10, 0.063095734448019331), exp10(double2(-10.0, -1.2)), 32, false);
@@ -1160,7 +1160,7 @@ public static void exp10_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), exp10(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp10_double3()
         {
             TestUtils.AreEqual(double3(1E-10, 0.063095734448019331, 1.0), exp10(double3(-10.0, -1.2, 0.0)), 32, false);
@@ -1168,14 +1168,14 @@ public static void exp10_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), exp10(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void exp10_double4()
         {
             TestUtils.AreEqual(double4(1E-10, 0.063095734448019331, 1.0, 15.848931924611135), exp10(double4(-10.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(0.0, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), exp10(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log_float()
         {
             TestUtils.AreEqual(-20.5409451f, log(1.2E-09f), 1, false);
@@ -1187,7 +1187,7 @@ public static void log_float()
             TestUtils.AreEqual(float.PositiveInfinity, log(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log_float2()
         {
             TestUtils.AreEqual(float2(-20.5409451f, 0f), log(float2(1.2E-09f, 1f)), 1, false);
@@ -1196,7 +1196,7 @@ public static void log_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), log(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log_float3()
         {
             TestUtils.AreEqual(float3(-20.5409451f, 0f, 23.2081718f), log(float3(1.2E-09f, 1f, 1.2E+10f)), 1, false);
@@ -1204,14 +1204,14 @@ public static void log_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), log(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log_float4()
         {
             TestUtils.AreEqual(float4(-20.5409451f, 0f, 23.2081718f, TestUtils.SignedFloatQNaN()), log(float4(1.2E-09f, 1f, 1.2E+10f, -1f)), 1, false);
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), log(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log_double()
         {
             TestUtils.AreEqual(-20.540944280152456, log(1.2E-09), 32, false);
@@ -1223,7 +1223,7 @@ public static void log_double()
             TestUtils.AreEqual(double.PositiveInfinity, log(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log_double2()
         {
             TestUtils.AreEqual(double2(-20.540944280152456, 0.0), log(double2(1.2E-09, 1.0)), 32, false);
@@ -1232,7 +1232,7 @@ public static void log_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), log(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log_double3()
         {
             TestUtils.AreEqual(double3(-20.540944280152456, 0.0, 23.208172486734409), log(double3(1.2E-09, 1.0, 12000000000.0)), 32, false);
@@ -1240,14 +1240,14 @@ public static void log_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), log(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log_double4()
         {
             TestUtils.AreEqual(double4(-20.540944280152456, 0.0, 23.208172486734409, TestUtils.SignedDoubleQNaN()), log(double4(1.2E-09, 1.0, 12000000000.0, -1.0)), 32, false);
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), log(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log2_float()
         {
             TestUtils.AreEqual(-29.63432f, log2(1.2E-09f), 1, false);
@@ -1259,7 +1259,7 @@ public static void log2_float()
             TestUtils.AreEqual(float.PositiveInfinity, log2(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log2_float2()
         {
             TestUtils.AreEqual(float2(-29.63432f, 0f), log2(float2(1.2E-09f, 1f)), 1, false);
@@ -1268,7 +1268,7 @@ public static void log2_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), log2(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log2_float3()
         {
             TestUtils.AreEqual(float3(-29.63432f, 0f, 33.4823151f), log2(float3(1.2E-09f, 1f, 1.2E+10f)), 1, false);
@@ -1276,14 +1276,14 @@ public static void log2_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), log2(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log2_float4()
         {
             TestUtils.AreEqual(float4(-29.63432f, 0f, 33.4823151f, TestUtils.SignedFloatQNaN()), log2(float4(1.2E-09f, 1f, 1.2E+10f, -1f)), 1, false);
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), log2(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log2_double()
         {
             TestUtils.AreEqual(-29.634318448152467, log2(1.2E-09), 32, false);
@@ -1295,7 +1295,7 @@ public static void log2_double()
             TestUtils.AreEqual(double.PositiveInfinity, log2(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log2_double2()
         {
             TestUtils.AreEqual(double2(-29.634318448152467, 0.0), log2(double2(1.2E-09, 1.0)), 32, false);
@@ -1304,7 +1304,7 @@ public static void log2_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), log2(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log2_double3()
         {
             TestUtils.AreEqual(double3(-29.634318448152467, 0.0, 33.482315354707417), log2(double3(1.2E-09, 1.0, 12000000000.0)), 32, false);
@@ -1312,14 +1312,14 @@ public static void log2_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), log2(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log2_double4()
         {
             TestUtils.AreEqual(double4(-29.634318448152467, 0.0, 33.482315354707417, TestUtils.SignedDoubleQNaN()), log2(double4(1.2E-09, 1.0, 12000000000.0, -1.0)), 32, false);
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), log2(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log10_float()
         {
             TestUtils.AreEqual(-8.920818f, log10(1.2E-09f), 1, false);
@@ -1331,7 +1331,7 @@ public static void log10_float()
             TestUtils.AreEqual(float.PositiveInfinity, log10(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log10_float2()
         {
             TestUtils.AreEqual(float2(-8.920818f, 0f), log10(float2(1.2E-09f, 1f)), 1, false);
@@ -1340,7 +1340,7 @@ public static void log10_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), log10(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log10_float3()
         {
             TestUtils.AreEqual(float3(-8.920818f, 0f, 10.0791817f), log10(float3(1.2E-09f, 1f, 1.2E+10f)), 1, false);
@@ -1348,14 +1348,14 @@ public static void log10_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), log10(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log10_float4()
         {
             TestUtils.AreEqual(float4(-8.920818f, 0f, 10.0791817f, TestUtils.SignedFloatQNaN()), log10(float4(1.2E-09f, 1f, 1.2E+10f, -1f)), 1, false);
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), log10(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log10_double()
         {
             TestUtils.AreEqual(-8.9208187539523749, log10(1.2E-09), 32, false);
@@ -1367,7 +1367,7 @@ public static void log10_double()
             TestUtils.AreEqual(double.PositiveInfinity, log10(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log10_double2()
         {
             TestUtils.AreEqual(double2(-8.9208187539523749, 0.0), log10(double2(1.2E-09, 1.0)), 32, false);
@@ -1376,7 +1376,7 @@ public static void log10_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), log10(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log10_double3()
         {
             TestUtils.AreEqual(double3(-8.9208187539523749, 0.0, 10.079181246047623), log10(double3(1.2E-09, 1.0, 12000000000.0)), 32, false);
@@ -1384,14 +1384,14 @@ public static void log10_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), log10(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void log10_double4()
         {
             TestUtils.AreEqual(double4(-8.9208187539523749, 0.0, 10.079181246047623, TestUtils.SignedDoubleQNaN()), log10(double4(1.2E-09, 1.0, 12000000000.0, -1.0)), 32, false);
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), log10(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void radians_float()
         {
             TestUtils.AreEqual(-2.154609f, radians(-123.45f), 1, false);
@@ -1402,7 +1402,7 @@ public static void radians_float()
             TestUtils.AreEqual(float.PositiveInfinity, radians(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void radians_float2()
         {
             TestUtils.AreEqual(float2(-2.154609f, 0f), radians(float2(-123.45f, 0f)), 1, false);
@@ -1410,21 +1410,21 @@ public static void radians_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), radians(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void radians_float3()
         {
             TestUtils.AreEqual(float3(-2.154609f, 0f, 2.154609f), radians(float3(-123.45f, 0f, 123.45f)), 1, false);
             TestUtils.AreEqual(float3(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity), radians(float3(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void radians_float4()
         {
             TestUtils.AreEqual(float4(-2.154609f, 0f, 2.154609f, float.NegativeInfinity), radians(float4(-123.45f, 0f, 123.45f, float.NegativeInfinity)), 1, false);
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), radians(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void radians_double()
         {
             TestUtils.AreEqual(-2.154608961587, radians(-123.45), 1, false);
@@ -1435,7 +1435,7 @@ public static void radians_double()
             TestUtils.AreEqual(double.PositiveInfinity, radians(double.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void radians_double2()
         {
             TestUtils.AreEqual(double2(-2.154608961587, 0.0), radians(double2(-123.45, 0.0)), 1, false);
@@ -1443,21 +1443,21 @@ public static void radians_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), radians(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void radians_double3()
         {
             TestUtils.AreEqual(double3(-2.154608961587, 0.0, 2.154608961587), radians(double3(-123.45, 0.0, 123.45)), 1, false);
             TestUtils.AreEqual(double3(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), radians(double3(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void radians_double4()
         {
             TestUtils.AreEqual(double4(-2.154608961587, 0.0, 2.154608961587, double.NegativeInfinity), radians(double4(-123.45, 0.0, 123.45, double.NegativeInfinity)), 1, false);
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), radians(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void degrees_float()
         {
             TestUtils.AreEqual(-7073.164f, degrees(-123.45f), 1, false);
@@ -1468,7 +1468,7 @@ public static void degrees_float()
             TestUtils.AreEqual(float.PositiveInfinity, degrees(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void degrees_float2()
         {
             TestUtils.AreEqual(float2(-7073.164f, 0f), degrees(float2(-123.45f, 0f)), 1, false);
@@ -1476,21 +1476,21 @@ public static void degrees_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), degrees(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void degrees_float3()
         {
             TestUtils.AreEqual(float3(-7073.164f, 0f, 7073.164f), degrees(float3(-123.45f, 0f, 123.45f)), 1, false);
             TestUtils.AreEqual(float3(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity), degrees(float3(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void degrees_float4()
         {
             TestUtils.AreEqual(float4(-7073.164f, 0f, 7073.164f, float.NegativeInfinity), degrees(float4(-123.45f, 0f, 123.45f, float.NegativeInfinity)), 1, false);
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), degrees(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void degrees_double()
         {
             TestUtils.AreEqual(-7073.1639808900127, degrees(-123.45), 1, false);
@@ -1501,7 +1501,7 @@ public static void degrees_double()
             TestUtils.AreEqual(double.PositiveInfinity, degrees(double.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void degrees_double2()
         {
             TestUtils.AreEqual(double2(-7073.1639808900127, 0.0), degrees(double2(-123.45, 0.0)), 1, false);
@@ -1509,21 +1509,21 @@ public static void degrees_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), degrees(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void degrees_double3()
         {
             TestUtils.AreEqual(double3(-7073.1639808900127, 0.0, 7073.1639808900127), degrees(double3(-123.45, 0.0, 123.45)), 1, false);
             TestUtils.AreEqual(double3(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), degrees(double3(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void degrees_double4()
         {
             TestUtils.AreEqual(double4(-7073.1639808900127, 0.0, 7073.1639808900127, double.NegativeInfinity), degrees(double4(-123.45, 0.0, 123.45, double.NegativeInfinity)), 1, false);
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), degrees(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sign_int()
         {
             TestUtils.AreEqual(-1, sign(-156));
@@ -1540,7 +1540,7 @@ public static void sign_int()
             TestUtils.AreEqual(-1, sign(-2147483648));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sign_int2()
         {
             TestUtils.AreEqual(int2(-1, -1), sign(int2(-156, -214748346)));
@@ -1551,7 +1551,7 @@ public static void sign_int2()
             TestUtils.AreEqual(int2(1, -1), sign(int2(2147483647, -2147483648)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sign_int3()
         {
             TestUtils.AreEqual(int3(-1, -1, 0), sign(int3(-156, -214748346, 0)));
@@ -1560,7 +1560,7 @@ public static void sign_int3()
             TestUtils.AreEqual(int3(1, 1, -1), sign(int3(64583, 2147483647, -2147483648)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sign_int4()
         {
             TestUtils.AreEqual(int4(-1, -1, 0, 1), sign(int4(-156, -214748346, 0, 214748346)));
@@ -1568,7 +1568,7 @@ public static void sign_int4()
             TestUtils.AreEqual(int4(-1, 1, 1, -1), sign(int4(-15379, 64583, 2147483647, -2147483648)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sign_float()
         {
             TestUtils.AreEqual(-1f, sign(-123.45f));
@@ -1581,7 +1581,7 @@ public static void sign_float()
             TestUtils.AreEqual(1f, sign(float.PositiveInfinity));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sign_float2()
         {
             TestUtils.AreEqual(float2(-1f, -1f), sign(float2(-123.45f, -1E-20f)));
@@ -1590,7 +1590,7 @@ public static void sign_float2()
             TestUtils.AreEqual(float2(0f, 1f), sign(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sign_float3()
         {
             TestUtils.AreEqual(float3(-1f, -1f, 0f), sign(float3(-123.45f, -1E-20f, 0f)));
@@ -1598,14 +1598,14 @@ public static void sign_float3()
             TestUtils.AreEqual(float3(0f, 1f, 1f), sign(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sign_float4()
         {
             TestUtils.AreEqual(float4(-1f, -1f, 0f, 1f), sign(float4(-123.45f, -1E-20f, 0f, 1E-10f)));
             TestUtils.AreEqual(float4(1f, -1f, 0f, 1f), sign(float4(123.45f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sign_double()
         {
             TestUtils.AreEqual(-1.0, sign(-123.45));
@@ -1618,7 +1618,7 @@ public static void sign_double()
             TestUtils.AreEqual(1.0, sign(double.PositiveInfinity));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sign_double2()
         {
             TestUtils.AreEqual(double2(-1.0, -1.0), sign(double2(-123.45, -1E-20)));
@@ -1627,7 +1627,7 @@ public static void sign_double2()
             TestUtils.AreEqual(double2(0.0, 1.0), sign(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sign_double3()
         {
             TestUtils.AreEqual(double3(-1.0, -1.0, 0.0), sign(double3(-123.45, -1E-20, 0.0)));
@@ -1635,14 +1635,14 @@ public static void sign_double3()
             TestUtils.AreEqual(double3(0.0, 1.0, 1.0), sign(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sign_double4()
         {
             TestUtils.AreEqual(double4(-1.0, -1.0, 0.0, 1.0), sign(double4(-123.45, -1E-20, 0.0, 1E-10)));
             TestUtils.AreEqual(double4(1.0, -1.0, 0.0, 1.0), sign(double4(123.45, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sqrt_float()
         {
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), sqrt(-1f), 1, false);
@@ -1654,7 +1654,7 @@ public static void sqrt_float()
             TestUtils.AreEqual(float.PositiveInfinity, sqrt(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sqrt_float2()
         {
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), 0f), sqrt(float2(-1f, 0f)), 1, false);
@@ -1663,7 +1663,7 @@ public static void sqrt_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), sqrt(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sqrt_float3()
         {
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 0f, 1E-05f), sqrt(float3(-1f, 0f, 1E-10f)), 1, false);
@@ -1671,14 +1671,14 @@ public static void sqrt_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), sqrt(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sqrt_float4()
         {
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), 0f, 1E-05f, 11.1108055f), sqrt(float4(-1f, 0f, 1E-10f, 123.45f)), 1, false);
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), sqrt(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sqrt_double()
         {
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), sqrt(-1.0), 1, false);
@@ -1690,7 +1690,7 @@ public static void sqrt_double()
             TestUtils.AreEqual(double.PositiveInfinity, sqrt(double.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sqrt_double2()
         {
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), 0.0), sqrt(double2(-1.0, 0.0)), 1, false);
@@ -1699,7 +1699,7 @@ public static void sqrt_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), sqrt(double2(double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sqrt_double3()
         {
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 0.0, 1E-05), sqrt(double3(-1.0, 0.0, 1E-10)), 1, false);
@@ -1707,14 +1707,14 @@ public static void sqrt_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), sqrt(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void sqrt_double4()
         {
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), 0.0, 1E-05, 11.11080555135405), sqrt(double4(-1.0, 0.0, 1E-10, 123.45)), 1, false);
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), sqrt(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rsqrt_float()
         {
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), rsqrt(-1f), 1, false);
@@ -1726,7 +1726,7 @@ public static void rsqrt_float()
             TestUtils.AreEqual(0f, rsqrt(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rsqrt_float2()
         {
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), rsqrt(float2(-1f, 0f)), 1, false);
@@ -1735,7 +1735,7 @@ public static void rsqrt_float2()
             TestUtils.AreEqual(float2(0f, 0f), rsqrt(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rsqrt_float3()
         {
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, 1E-05f), rsqrt(float3(-1f, 0f, 1E+10f)), 1, false);
@@ -1743,14 +1743,14 @@ public static void rsqrt_float3()
             TestUtils.AreEqual(float3(0f, 0f, 0f), rsqrt(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rsqrt_float4()
         {
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, 1E-05f, 0.09000248f), rsqrt(float4(-1f, 0f, 1E+10f, 123.45f)), 1, false);
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), 0f, 0f), rsqrt(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rsqrt_double()
         {
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), rsqrt(-1.0), 1, false);
@@ -1762,7 +1762,7 @@ public static void rsqrt_double()
             TestUtils.AreEqual(0.0, rsqrt(double.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rsqrt_double2()
         {
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), rsqrt(double2(-1.0, 0.0)), 1, false);
@@ -1771,7 +1771,7 @@ public static void rsqrt_double2()
             TestUtils.AreEqual(double2(0.0, 0.0), rsqrt(double2(double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rsqrt_double3()
         {
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, 1E-05), rsqrt(double3(-1.0, 0.0, 10000000000.0)), 1, false);
@@ -1779,14 +1779,14 @@ public static void rsqrt_double3()
             TestUtils.AreEqual(double3(0.0, 0.0, 0.0), rsqrt(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rsqrt_double4()
         {
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, 1E-05, 0.090002475102098425), rsqrt(double4(-1.0, 0.0, 10000000000.0, 123.45)), 1, false);
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), 0.0, 0.0), rsqrt(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rcp_float()
         {
             TestUtils.AreEqual(-0.008100445f, rcp(-123.45f), 1, false);
@@ -1796,7 +1796,7 @@ public static void rcp_float()
             TestUtils.AreEqual(0f, rcp(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rcp_float2()
         {
             TestUtils.AreEqual(float2(-0.008100445f, float.PositiveInfinity), rcp(float2(-123.45f, 0f)), 1, false);
@@ -1804,21 +1804,21 @@ public static void rcp_float2()
             TestUtils.AreEqual(float2(0f, 0f), rcp(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rcp_float3()
         {
             TestUtils.AreEqual(float3(-0.008100445f, float.PositiveInfinity, 0.008100445f), rcp(float3(-123.45f, 0f, 123.45f)), 1, false);
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 0f, 0f), rcp(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rcp_float4()
         {
             TestUtils.AreEqual(float4(-0.008100445f, float.PositiveInfinity, 0.008100445f, TestUtils.SignedFloatQNaN()), rcp(float4(-123.45f, 0f, 123.45f, TestUtils.SignedFloatQNaN())), 1, false);
             TestUtils.AreEqual(float4(0f, 0f, 0f, 0f), rcp(float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rcp_double()
         {
             TestUtils.AreEqual(-0.0081004455245038479, rcp(-123.45), 1, false);
@@ -1828,7 +1828,7 @@ public static void rcp_double()
             TestUtils.AreEqual(0.0, rcp(double.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rcp_double2()
         {
             TestUtils.AreEqual(double2(-0.0081004455245038479, double.PositiveInfinity), rcp(double2(-123.45, 0.0)), 1, false);
@@ -1836,21 +1836,21 @@ public static void rcp_double2()
             TestUtils.AreEqual(double2(0.0, 0.0), rcp(double2(double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rcp_double3()
         {
             TestUtils.AreEqual(double3(-0.0081004455245038479, double.PositiveInfinity, 0.0081004455245038479), rcp(double3(-123.45, 0.0, 123.45)), 1, false);
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 0.0, 0.0), rcp(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rcp_double4()
         {
             TestUtils.AreEqual(double4(-0.0081004455245038479, double.PositiveInfinity, 0.0081004455245038479, TestUtils.SignedDoubleQNaN()), rcp(double4(-123.45, 0.0, 123.45, TestUtils.SignedDoubleQNaN())), 1, false);
             TestUtils.AreEqual(double4(0.0, 0.0, 0.0, 0.0), rcp(double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void floor_float()
         {
             TestUtils.AreEqual(float.NegativeInfinity, floor(float.NegativeInfinity));
@@ -1865,7 +1865,7 @@ public static void floor_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), floor(TestUtils.SignedFloatQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void floor_float2()
         {
             TestUtils.AreEqual(float2(float.NegativeInfinity, -101f), floor(float2(float.NegativeInfinity, -100.51f)));
@@ -1875,7 +1875,7 @@ public static void floor_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN()), floor(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void floor_float3()
         {
             TestUtils.AreEqual(float3(float.NegativeInfinity, -101f, -101f), floor(float3(float.NegativeInfinity, -100.51f, -100.5f)));
@@ -1884,7 +1884,7 @@ public static void floor_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), floor(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void floor_float4()
         {
             TestUtils.AreEqual(float4(float.NegativeInfinity, -101f, -101f, -101f), floor(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f)));
@@ -1892,7 +1892,7 @@ public static void floor_float4()
             TestUtils.AreEqual(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), floor(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void floor_double()
         {
             TestUtils.AreEqual(double.NegativeInfinity, floor(double.NegativeInfinity));
@@ -1907,7 +1907,7 @@ public static void floor_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), floor(TestUtils.SignedDoubleQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void floor_double2()
         {
             TestUtils.AreEqual(double2(double.NegativeInfinity, -101.0), floor(double2(double.NegativeInfinity, -100.51)));
@@ -1917,7 +1917,7 @@ public static void floor_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN()), floor(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void floor_double3()
         {
             TestUtils.AreEqual(double3(double.NegativeInfinity, -101.0, -101.0), floor(double3(double.NegativeInfinity, -100.51, -100.5)));
@@ -1926,7 +1926,7 @@ public static void floor_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), floor(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void floor_double4()
         {
             TestUtils.AreEqual(double4(double.NegativeInfinity, -101.0, -101.0, -101.0), floor(double4(double.NegativeInfinity, -100.51, -100.5, -100.49)));
@@ -1934,7 +1934,7 @@ public static void floor_double4()
             TestUtils.AreEqual(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), floor(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceil_float()
         {
             TestUtils.AreEqual(float.NegativeInfinity, ceil(float.NegativeInfinity));
@@ -1949,7 +1949,7 @@ public static void ceil_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), ceil(TestUtils.SignedFloatQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceil_float2()
         {
             TestUtils.AreEqual(float2(float.NegativeInfinity, -100f), ceil(float2(float.NegativeInfinity, -100.51f)));
@@ -1959,7 +1959,7 @@ public static void ceil_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN()), ceil(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceil_float3()
         {
             TestUtils.AreEqual(float3(float.NegativeInfinity, -100f, -100f), ceil(float3(float.NegativeInfinity, -100.51f, -100.5f)));
@@ -1968,7 +1968,7 @@ public static void ceil_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), ceil(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceil_float4()
         {
             TestUtils.AreEqual(float4(float.NegativeInfinity, -100f, -100f, -100f), ceil(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f)));
@@ -1976,7 +1976,7 @@ public static void ceil_float4()
             TestUtils.AreEqual(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), ceil(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceil_double()
         {
             TestUtils.AreEqual(double.NegativeInfinity, ceil(double.NegativeInfinity));
@@ -1991,7 +1991,7 @@ public static void ceil_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), ceil(TestUtils.SignedDoubleQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceil_double2()
         {
             TestUtils.AreEqual(double2(double.NegativeInfinity, -100.0), ceil(double2(double.NegativeInfinity, -100.51)));
@@ -2001,7 +2001,7 @@ public static void ceil_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN()), ceil(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceil_double3()
         {
             TestUtils.AreEqual(double3(double.NegativeInfinity, -100.0, -100.0), ceil(double3(double.NegativeInfinity, -100.51, -100.5)));
@@ -2010,7 +2010,7 @@ public static void ceil_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), ceil(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceil_double4()
         {
             TestUtils.AreEqual(double4(double.NegativeInfinity, -100.0, -100.0, -100.0), ceil(double4(double.NegativeInfinity, -100.51, -100.5, -100.49)));
@@ -2018,7 +2018,7 @@ public static void ceil_double4()
             TestUtils.AreEqual(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), ceil(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void round_float()
         {
             TestUtils.AreEqual(float.NegativeInfinity, round(float.NegativeInfinity));
@@ -2034,7 +2034,7 @@ public static void round_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), round(TestUtils.SignedFloatQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void round_float2()
         {
             TestUtils.AreEqual(float2(float.NegativeInfinity, -101f), round(float2(float.NegativeInfinity, -100.51f)));
@@ -2045,7 +2045,7 @@ public static void round_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), round(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void round_float3()
         {
             TestUtils.AreEqual(float3(float.NegativeInfinity, -101f, -100f), round(float3(float.NegativeInfinity, -100.51f, -100.5f)));
@@ -2054,7 +2054,7 @@ public static void round_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), round(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void round_float4()
         {
             TestUtils.AreEqual(float4(float.NegativeInfinity, -101f, -100f, -100f), round(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f)));
@@ -2062,7 +2062,7 @@ public static void round_float4()
             TestUtils.AreEqual(float4(102f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), round(float4(101.5f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void round_double()
         {
             TestUtils.AreEqual(double.NegativeInfinity, round(double.NegativeInfinity));
@@ -2078,7 +2078,7 @@ public static void round_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), round(TestUtils.SignedDoubleQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void round_double2()
         {
             TestUtils.AreEqual(double2(double.NegativeInfinity, -101.0), round(double2(double.NegativeInfinity, -100.51)));
@@ -2089,7 +2089,7 @@ public static void round_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), round(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void round_double3()
         {
             TestUtils.AreEqual(double3(double.NegativeInfinity, -101.0, -100.0), round(double3(double.NegativeInfinity, -100.51, -100.5)));
@@ -2098,7 +2098,7 @@ public static void round_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), round(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void round_double4()
         {
             TestUtils.AreEqual(double4(double.NegativeInfinity, -101.0, -100.0, -100.0), round(double4(double.NegativeInfinity, -100.51, -100.5, -100.49)));
@@ -2106,7 +2106,7 @@ public static void round_double4()
             TestUtils.AreEqual(double4(102.0, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), round(double4(101.5, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void trunc_float()
         {
             TestUtils.AreEqual(float.NegativeInfinity, trunc(float.NegativeInfinity));
@@ -2122,7 +2122,7 @@ public static void trunc_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), trunc(TestUtils.SignedFloatQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void trunc_float2()
         {
             TestUtils.AreEqual(float2(float.NegativeInfinity, -100f), trunc(float2(float.NegativeInfinity, -100.51f)));
@@ -2133,7 +2133,7 @@ public static void trunc_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), trunc(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void trunc_float3()
         {
             TestUtils.AreEqual(float3(float.NegativeInfinity, -100f, -100f), trunc(float3(float.NegativeInfinity, -100.51f, -100.5f)));
@@ -2142,7 +2142,7 @@ public static void trunc_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), trunc(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void trunc_float4()
         {
             TestUtils.AreEqual(float4(float.NegativeInfinity, -100f, -100f, -100f), trunc(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f)));
@@ -2150,7 +2150,7 @@ public static void trunc_float4()
             TestUtils.AreEqual(float4(101f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), trunc(float4(101.5f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void trunc_double()
         {
             TestUtils.AreEqual(double.NegativeInfinity, trunc(double.NegativeInfinity));
@@ -2166,7 +2166,7 @@ public static void trunc_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), trunc(TestUtils.SignedDoubleQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void trunc_double2()
         {
             TestUtils.AreEqual(double2(double.NegativeInfinity, -100.0), trunc(double2(double.NegativeInfinity, -100.51)));
@@ -2177,7 +2177,7 @@ public static void trunc_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), trunc(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void trunc_double3()
         {
             TestUtils.AreEqual(double3(double.NegativeInfinity, -100.0, -100.0), trunc(double3(double.NegativeInfinity, -100.51, -100.5)));
@@ -2186,7 +2186,7 @@ public static void trunc_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), trunc(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void trunc_double4()
         {
             TestUtils.AreEqual(double4(double.NegativeInfinity, -100.0, -100.0, -100.0), trunc(double4(double.NegativeInfinity, -100.51, -100.5, -100.49)));
@@ -2194,7 +2194,7 @@ public static void trunc_double4()
             TestUtils.AreEqual(double4(101.0, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), trunc(double4(101.5, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void frac_float()
         {
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), frac(float.NegativeInfinity), 64, false);
@@ -2206,7 +2206,7 @@ public static void frac_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), frac(TestUtils.SignedFloatQNaN()), 64, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void frac_float2()
         {
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), 0f), frac(float2(float.NegativeInfinity, -1E+20f)), 64, false);
@@ -2215,7 +2215,7 @@ public static void frac_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), frac(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 64, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void frac_float3()
         {
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 0f, 0.7f), frac(float3(float.NegativeInfinity, -1E+20f, -100.3f)), 64, false);
@@ -2223,14 +2223,14 @@ public static void frac_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), frac(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 64, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void frac_float4()
         {
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), 0f, 0.7f, 0f), frac(float4(float.NegativeInfinity, -1E+20f, -100.3f, 0f)), 64, false);
             TestUtils.AreEqual(float4(0.8f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), frac(float4(100.8f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 64, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void frac_double()
         {
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), frac(double.NegativeInfinity), 64, false);
@@ -2242,7 +2242,7 @@ public static void frac_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), frac(TestUtils.SignedDoubleQNaN()), 64, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void frac_double2()
         {
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), 0.0), frac(double2(double.NegativeInfinity, -1E+20)), 64, false);
@@ -2251,7 +2251,7 @@ public static void frac_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), frac(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 64, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void frac_double3()
         {
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 0.0, 0.7), frac(double3(double.NegativeInfinity, -1E+20, -100.3)), 64, false);
@@ -2259,14 +2259,14 @@ public static void frac_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), frac(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 64, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void frac_double4()
         {
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), 0.0, 0.7, 0.0), frac(double4(double.NegativeInfinity, -1E+20, -100.3, 0.0)), 64, false);
             TestUtils.AreEqual(double4(0.8, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), frac(double4(100.8, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 64, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lerp_float()
         {
             TestUtils.AreEqual(-967.77f, lerp(-123.45f, 439.43f, -1.5f), 1, false);
@@ -2275,27 +2275,27 @@ public static void lerp_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), lerp(-123.45f, 439.43f, TestUtils.SignedFloatQNaN()), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lerp_float2()
         {
             TestUtils.AreEqual(float2(-967.77f, 157.99f), lerp(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(-1.5f, 0.5f)), 1, false);
             TestUtils.AreEqual(float2(2972.39f, TestUtils.SignedFloatQNaN()), lerp(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(5.5f, TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lerp_float3()
         {
             TestUtils.AreEqual(float3(-967.77f, 157.99f, 2972.39f), lerp(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(-1.5f, 0.5f, 5.5f)), 1, false);
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), lerp(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lerp_float4()
         {
             TestUtils.AreEqual(float4(-967.77f, 157.99f, 2972.39f, TestUtils.SignedFloatQNaN()), lerp(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, 439.43f, 439.43f, 439.43f), float4(-1.5f, 0.5f, 5.5f, TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lerp_double()
         {
             TestUtils.AreEqual(-967.77, lerp(-123.45, 439.43, -1.5), 1, false);
@@ -2304,27 +2304,27 @@ public static void lerp_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), lerp(-123.45, 439.43, TestUtils.SignedDoubleQNaN()), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lerp_double2()
         {
             TestUtils.AreEqual(double2(-967.77, 157.99), lerp(double2(-123.45, -123.45), double2(439.43, 439.43), double2(-1.5, 0.5)), 1, false);
             TestUtils.AreEqual(double2(2972.39, TestUtils.SignedDoubleQNaN()), lerp(double2(-123.45, -123.45), double2(439.43, 439.43), double2(5.5, TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lerp_double3()
         {
             TestUtils.AreEqual(double3(-967.77, 157.99, 2972.39), lerp(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(-1.5, 0.5, 5.5)), 1, false);
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), lerp(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void lerp_double4()
         {
             TestUtils.AreEqual(double4(-967.77, 157.99, 2972.39, TestUtils.SignedDoubleQNaN()), lerp(double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, 439.43, 439.43, 439.43), double4(-1.5, 0.5, 5.5, TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void unlerp_float()
         {
             TestUtils.AreEqual(-0.232465178f, unlerp(-123.45f, 439.43f, -254.3f), 4, false);
@@ -2337,7 +2337,7 @@ public static void unlerp_float()
             TestUtils.AreEqual(-0.3422932f, unlerp(439.43f, -123.45f, 632.1f), 4, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void unlerp_float2()
         {
             TestUtils.AreEqual(float2(-0.232465178f, 0.219318509f), unlerp(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(-254.3f, 0f)), 4, false);
@@ -2346,7 +2346,7 @@ public static void unlerp_float2()
             TestUtils.AreEqual(float2(0.7806815f, -0.3422932f), unlerp(float2(439.43f, 439.43f), float2(-123.45f, -123.45f), float2(0f, 632.1f)), 4, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void unlerp_float3()
         {
             TestUtils.AreEqual(float3(-0.232465178f, 0.219318509f, 1.34229326f), unlerp(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(-254.3f, 0f, 632.1f)), 4, false);
@@ -2354,14 +2354,14 @@ public static void unlerp_float3()
             TestUtils.AreEqual(float3(0.7806815f, -0.3422932f, -0.3422932f), unlerp(float3(439.43f, 439.43f, 439.43f), float3(-123.45f, -123.45f, -123.45f), float3(0f, 632.1f, 632.1f)), 4, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void unlerp_float4()
         {
             TestUtils.AreEqual(float4(-0.232465178f, 0.219318509f, 1.34229326f, float.NegativeInfinity), unlerp(float4(-123.45f, -123.45f, -123.45f, 123.4f), float4(439.43f, 439.43f, 439.43f, 123.4f), float4(-254.3f, 0f, 632.1f, -430f)), 4, false);
             TestUtils.AreEqual(float4(float.PositiveInfinity, 1.23246515f, 0.7806815f, -0.3422932f), unlerp(float4(123.4f, 439.43f, 439.43f, 439.43f), float4(123.4f, -123.45f, -123.45f, -123.45f), float4(430f, -254.3f, 0f, 632.1f)), 4, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void unlerp_double()
         {
             TestUtils.AreEqual(-0.23246517907902217, unlerp(-123.45, 439.43, -254.3), 4, false);
@@ -2374,7 +2374,7 @@ public static void unlerp_double()
             TestUtils.AreEqual(-0.34229320636725413, unlerp(439.43, -123.45, 632.1), 4, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void unlerp_double2()
         {
             TestUtils.AreEqual(double2(-0.23246517907902217, 0.21931850483229107), unlerp(double2(-123.45, -123.45), double2(439.43, 439.43), double2(-254.3, 0.0)), 4, false);
@@ -2383,7 +2383,7 @@ public static void unlerp_double2()
             TestUtils.AreEqual(double2(0.78068149516770891, -0.34229320636725413), unlerp(double2(439.43, 439.43), double2(-123.45, -123.45), double2(0.0, 632.1)), 4, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void unlerp_double3()
         {
             TestUtils.AreEqual(double3(-0.23246517907902217, 0.21931850483229107, 1.3422932063672541), unlerp(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(-254.3, 0.0, 632.1)), 4, false);
@@ -2391,14 +2391,14 @@ public static void unlerp_double3()
             TestUtils.AreEqual(double3(0.78068149516770891, -0.34229320636725413, -0.34229320636725413), unlerp(double3(439.43, 439.43, 439.43), double3(-123.45, -123.45, -123.45), double3(0.0, 632.1, 632.1)), 4, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void unlerp_double4()
         {
             TestUtils.AreEqual(double4(-0.23246517907902217, 0.21931850483229107, 1.3422932063672541, double.NegativeInfinity), unlerp(double4(-123.45, -123.45, -123.45, 123.4), double4(439.43, 439.43, 439.43, 123.4), double4(-254.3, 0.0, 632.1, -430.0)), 4, false);
             TestUtils.AreEqual(double4(double.PositiveInfinity, 1.2324651790790222, 0.78068149516770891, -0.34229320636725413), unlerp(double4(123.4, 439.43, 439.43, 439.43), double4(123.4, -123.45, -123.45, -123.45), double4(430.0, -254.3, 0.0, 632.1)), 4, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void remap_float()
         {
             TestUtils.AreEqual(529.0331f, remap(-123.45f, 439.43f, 541.3f, 631.5f, -200f), 4, false);
@@ -2414,7 +2414,7 @@ public static void remap_float()
             TestUtils.AreEqual(float.PositiveInfinity, remap(-123.45f, -123.45f, 541.3f, 631.5f, -100f), 4, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void remap_float2()
         {
             TestUtils.AreEqual(float2(529.0331f, 545.0578f), remap(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(541.3f, 541.3f), float2(631.5f, 631.5f), float2(-200f, -100f)), 4, false);
@@ -2425,7 +2425,7 @@ public static void remap_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), remap(float2(-123.45f, -123.45f), float2(-123.45f, -123.45f), float2(541.3f, 541.3f), float2(631.5f, 631.5f), float2(-100f, -100f)), 4, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void remap_float3()
         {
             TestUtils.AreEqual(float3(529.0331f, 545.0578f, 641.2062f), remap(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(541.3f, 541.3f, 541.3f), float3(631.5f, 631.5f, 631.5f), float3(-200f, -100f, 500f)), 4, false);
@@ -2434,7 +2434,7 @@ public static void remap_float3()
             TestUtils.AreEqual(float3(float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity), remap(float3(-123.45f, -123.45f, -123.45f), float3(-123.45f, -123.45f, -123.45f), float3(541.3f, 541.3f, 541.3f), float3(631.5f, 631.5f, 631.5f), float3(-200f, -100f, -100f)), 4, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void remap_float4()
         {
             TestUtils.AreEqual(float4(529.0331f, 545.0578f, 641.2062f, 643.7669f), remap(float4(-123.45f, -123.45f, -123.45f, 439.43f), float4(439.43f, 439.43f, 439.43f, -123.45f), float4(541.3f, 541.3f, 541.3f, 541.3f), float4(631.5f, 631.5f, 631.5f, 631.5f), float4(-200f, -100f, 500f, -200f)), 4, false);
@@ -2442,7 +2442,7 @@ public static void remap_float4()
             TestUtils.AreEqual(float4(531.5938f, float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity), remap(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, -123.45f, -123.45f, -123.45f), float4(631.5f, 541.3f, 541.3f, 541.3f), float4(541.3f, 631.5f, 631.5f, 631.5f), float4(500f, -200f, -100f, -100f)), 4, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void remap_double()
         {
             TestUtils.AreEqual(529.03306921546334, remap(-123.45, 439.43, 541.3, 631.5, -200.0), 4, false);
@@ -2458,7 +2458,7 @@ public static void remap_double()
             TestUtils.AreEqual(double.PositiveInfinity, remap(-123.45, -123.45, 541.3, 631.5, -100.0), 4, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void remap_double2()
         {
             TestUtils.AreEqual(double2(529.03306921546334, 545.057799175668), remap(double2(-123.45, -123.45), double2(439.43, 439.43), double2(541.3, 541.3), double2(631.5, 631.5), double2(-200.0, -100.0)), 4, false);
@@ -2469,7 +2469,7 @@ public static void remap_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), remap(double2(-123.45, -123.45), double2(-123.45, -123.45), double2(541.3, 541.3), double2(631.5, 631.5), double2(-100.0, -100.0)), 4, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void remap_double3()
         {
             TestUtils.AreEqual(double3(529.03306921546334, 545.057799175668, 641.206178936896), remap(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(541.3, 541.3, 541.3), double3(631.5, 631.5, 631.5), double3(-200.0, -100.0, 500.0)), 4, false);
@@ -2478,7 +2478,7 @@ public static void remap_double3()
             TestUtils.AreEqual(double3(double.NegativeInfinity, double.PositiveInfinity, double.PositiveInfinity), remap(double3(-123.45, -123.45, -123.45), double3(-123.45, -123.45, -123.45), double3(541.3, 541.3, 541.3), double3(631.5, 631.5, 631.5), double3(-200.0, -100.0, -100.0)), 4, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void remap_double4()
         {
             TestUtils.AreEqual(double4(529.03306921546334, 545.057799175668, 641.206178936896, 643.76693078453673), remap(double4(-123.45, -123.45, -123.45, 439.43), double4(439.43, 439.43, 439.43, -123.45), double4(541.3, 541.3, 541.3, 541.3), double4(631.5, 631.5, 631.5, 631.5), double4(-200.0, -100.0, 500.0, -200.0)), 4, false);
@@ -2486,7 +2486,7 @@ public static void remap_double4()
             TestUtils.AreEqual(double4(531.59382106310409, double.NegativeInfinity, double.PositiveInfinity, double.PositiveInfinity), remap(double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, -123.45, -123.45, -123.45), double4(631.5, 541.3, 541.3, 541.3), double4(541.3, 631.5, 631.5, 631.5), double4(500.0, -200.0, -100.0, -100.0)), 4, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_int()
         {
             TestUtils.AreEqual(-123, clamp(-2147483648, -123, 439));
@@ -2499,7 +2499,7 @@ public static void clamp_int()
             TestUtils.AreEqual(439, clamp(2147483647, -123, 439));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_int2()
         {
             TestUtils.AreEqual(int2(-123, -123), clamp(int2(-2147483648, -254), int2(-123, -123), int2(439, 439)));
@@ -2508,7 +2508,7 @@ public static void clamp_int2()
             TestUtils.AreEqual(int2(439, 439), clamp(int2(632, 2147483647), int2(439, -123), int2(-123, 439)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_int3()
         {
             TestUtils.AreEqual(int3(-123, -123, 246), clamp(int3(-2147483648, -254, 246), int3(-123, -123, -123), int3(439, 439, 439)));
@@ -2516,14 +2516,14 @@ public static void clamp_int3()
             TestUtils.AreEqual(int3(439, 439, 439), clamp(int3(632, 2147483647, 2147483647), int3(439, -123, -123), int3(-123, 439, 439)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_int4()
         {
             TestUtils.AreEqual(int4(-123, -123, 246, 439), clamp(int4(-2147483648, -254, 246, 632), int4(-123, -123, -123, -123), int4(439, 439, 439, 439)));
             TestUtils.AreEqual(int4(439, 439, 439, 439), clamp(int4(-254, 246, 632, 2147483647), int4(439, 439, 439, -123), int4(-123, -123, -123, 439)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_uint()
         {
             TestUtils.AreEqual(123u, clamp(0u, 123u, 439u));
@@ -2536,7 +2536,7 @@ public static void clamp_uint()
             TestUtils.AreEqual(439u, clamp(4294967295u, 123u, 439u));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_uint2()
         {
             TestUtils.AreEqual(uint2(123u, 123u), clamp(uint2(0u, 54u), uint2(123u, 123u), uint2(439u, 439u)));
@@ -2545,7 +2545,7 @@ public static void clamp_uint2()
             TestUtils.AreEqual(uint2(439u, 439u), clamp(uint2(632u, 4294967295u), uint2(439u, 123u), uint2(123u, 439u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_uint3()
         {
             TestUtils.AreEqual(uint3(123u, 123u, 246u), clamp(uint3(0u, 54u, 246u), uint3(123u, 123u, 123u), uint3(439u, 439u, 439u)));
@@ -2553,14 +2553,14 @@ public static void clamp_uint3()
             TestUtils.AreEqual(uint3(439u, 439u, 439u), clamp(uint3(632u, 4294967295u, 4294967295u), uint3(439u, 123u, 123u), uint3(123u, 439u, 439u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_uint4()
         {
             TestUtils.AreEqual(uint4(123u, 123u, 246u, 439u), clamp(uint4(0u, 54u, 246u, 632u), uint4(123u, 123u, 123u, 123u), uint4(439u, 439u, 439u, 439u)));
             TestUtils.AreEqual(uint4(439u, 439u, 439u, 439u), clamp(uint4(54u, 246u, 632u, 4294967295u), uint4(439u, 439u, 439u, 123u), uint4(123u, 123u, 123u, 439u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_long()
         {
             TestUtils.AreEqual(-123L, clamp(-9223372036854775808L, -123L, 439L));
@@ -2573,7 +2573,7 @@ public static void clamp_long()
             TestUtils.AreEqual(439L, clamp(9223372036854775807L, -123L, 439L));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_ulong()
         {
             TestUtils.AreEqual(123UL, clamp(0UL, 123UL, 439UL));
@@ -2586,7 +2586,7 @@ public static void clamp_ulong()
             TestUtils.AreEqual(439UL, clamp(18446744073709551615UL, 123UL, 439UL));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_float()
         {
             TestUtils.AreEqual(-123.45f, clamp(float.NegativeInfinity, -123.45f, 439.43f));
@@ -2600,7 +2600,7 @@ public static void clamp_float()
             TestUtils.AreEqual(439.43f, clamp(TestUtils.SignedFloatQNaN(), -123.45f, 439.43f));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_float2()
         {
             TestUtils.AreEqual(float2(-123.45f, -123.45f), clamp(float2(float.NegativeInfinity, -254.3f), float2(-123.45f, -123.45f), float2(439.43f, 439.43f)));
@@ -2610,7 +2610,7 @@ public static void clamp_float2()
             TestUtils.AreEqual(float2(439.43f, 439.43f), clamp(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(-123.45f, -123.45f), float2(439.43f, 439.43f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_float3()
         {
             TestUtils.AreEqual(float3(-123.45f, -123.45f, 246.3f), clamp(float3(float.NegativeInfinity, -254.3f, 246.3f), float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f)));
@@ -2618,7 +2618,7 @@ public static void clamp_float3()
             TestUtils.AreEqual(float3(439.43f, 439.43f, 439.43f), clamp(float3(632.1f, float.PositiveInfinity, TestUtils.SignedFloatQNaN()), float3(439.43f, -123.45f, -123.45f), float3(-123.45f, 439.43f, 439.43f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_float4()
         {
             TestUtils.AreEqual(float4(-123.45f, -123.45f, 246.3f, 439.43f), clamp(float4(float.NegativeInfinity, -254.3f, 246.3f, 632.1f), float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, 439.43f, 439.43f, 439.43f)));
@@ -2626,7 +2626,7 @@ public static void clamp_float4()
             TestUtils.AreEqual(float4(439.43f, 439.43f, 439.43f, 439.43f), clamp(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, 439.43f, 439.43f, 439.43f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_double()
         {
             TestUtils.AreEqual(-123.45, clamp(double.NegativeInfinity, -123.45, 439.43));
@@ -2640,7 +2640,7 @@ public static void clamp_double()
             TestUtils.AreEqual(439.43, clamp(TestUtils.SignedDoubleQNaN(), -123.45, 439.43));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_double2()
         {
             TestUtils.AreEqual(double2(-123.45, -123.45), clamp(double2(double.NegativeInfinity, -254.3), double2(-123.45, -123.45), double2(439.43, 439.43)));
@@ -2650,7 +2650,7 @@ public static void clamp_double2()
             TestUtils.AreEqual(double2(439.43, 439.43), clamp(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(-123.45, -123.45), double2(439.43, 439.43)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_double3()
         {
             TestUtils.AreEqual(double3(-123.45, -123.45, 246.3), clamp(double3(double.NegativeInfinity, -254.3, 246.3), double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43)));
@@ -2658,7 +2658,7 @@ public static void clamp_double3()
             TestUtils.AreEqual(double3(439.43, 439.43, 439.43), clamp(double3(632.1, double.PositiveInfinity, TestUtils.SignedDoubleQNaN()), double3(439.43, -123.45, -123.45), double3(-123.45, 439.43, 439.43)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void clamp_double4()
         {
             TestUtils.AreEqual(double4(-123.45, -123.45, 246.3, 439.43), clamp(double4(double.NegativeInfinity, -254.3, 246.3, 632.1), double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, 439.43, 439.43, 439.43)));
@@ -2666,7 +2666,7 @@ public static void clamp_double4()
             TestUtils.AreEqual(double4(439.43, 439.43, 439.43, 439.43), clamp(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, 439.43, 439.43, 439.43)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void saturate_float()
         {
             TestUtils.AreEqual(0f, saturate(float.NegativeInfinity));
@@ -2679,7 +2679,7 @@ public static void saturate_float()
             TestUtils.AreEqual(1f, saturate(TestUtils.SignedFloatQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void saturate_float2()
         {
             TestUtils.AreEqual(float2(0f, 0f), saturate(float2(float.NegativeInfinity, -123.45f)));
@@ -2688,7 +2688,7 @@ public static void saturate_float2()
             TestUtils.AreEqual(float2(1f, 1f), saturate(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void saturate_float3()
         {
             TestUtils.AreEqual(float3(0f, 0f, 0f), saturate(float3(float.NegativeInfinity, -123.45f, 0f)));
@@ -2696,14 +2696,14 @@ public static void saturate_float3()
             TestUtils.AreEqual(float3(1f, 1f, 1f), saturate(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void saturate_float4()
         {
             TestUtils.AreEqual(float4(0f, 0f, 0f, 0.5f), saturate(float4(float.NegativeInfinity, -123.45f, 0f, 0.5f)));
             TestUtils.AreEqual(float4(1f, 1f, 1f, 1f), saturate(float4(1f, 123.45f, float.PositiveInfinity, TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void saturate_double()
         {
             TestUtils.AreEqual(0.0, saturate(double.NegativeInfinity));
@@ -2716,7 +2716,7 @@ public static void saturate_double()
             TestUtils.AreEqual(1.0, saturate(TestUtils.SignedDoubleQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void saturate_double2()
         {
             TestUtils.AreEqual(double2(0.0, 0.0), saturate(double2(double.NegativeInfinity, -123.45)));
@@ -2725,7 +2725,7 @@ public static void saturate_double2()
             TestUtils.AreEqual(double2(1.0, 1.0), saturate(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void saturate_double3()
         {
             TestUtils.AreEqual(double3(0.0, 0.0, 0.0), saturate(double3(double.NegativeInfinity, -123.45, 0.0)));
@@ -2733,14 +2733,14 @@ public static void saturate_double3()
             TestUtils.AreEqual(double3(1.0, 1.0, 1.0), saturate(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void saturate_double4()
         {
             TestUtils.AreEqual(double4(0.0, 0.0, 0.0, 0.5), saturate(double4(double.NegativeInfinity, -123.45, 0.0, 0.5)));
             TestUtils.AreEqual(double4(1.0, 1.0, 1.0, 1.0), saturate(double4(1.0, 123.45, double.PositiveInfinity, TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void step_float()
         {
             TestUtils.AreEqual(0f, step(-123.45f, float.NegativeInfinity));
@@ -2770,7 +2770,7 @@ public static void step_float()
             TestUtils.AreEqual(0f, step(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void step_float2()
         {
             TestUtils.AreEqual(float2(0f, 0f), step(float2(-123.45f, -123.45f), float2(float.NegativeInfinity, -200f)));
@@ -2788,7 +2788,7 @@ public static void step_float2()
             TestUtils.AreEqual(float2(0f, 0f), step(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void step_float3()
         {
             TestUtils.AreEqual(float3(0f, 0f, 1f), step(float3(-123.45f, -123.45f, -123.45f), float3(float.NegativeInfinity, -200f, 200f)));
@@ -2802,7 +2802,7 @@ public static void step_float3()
             TestUtils.AreEqual(float3(0f, 0f, 0f), step(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void step_float4()
         {
             TestUtils.AreEqual(float4(0f, 0f, 1f, 1f), step(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(float.NegativeInfinity, -200f, 200f, float.PositiveInfinity)));
@@ -2814,7 +2814,7 @@ public static void step_float4()
             TestUtils.AreEqual(float4(0f, 0f, 0f, 0f), step(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void step_double()
         {
             TestUtils.AreEqual(0.0, step(-123.45, double.NegativeInfinity));
@@ -2844,7 +2844,7 @@ public static void step_double()
             TestUtils.AreEqual(0.0, step(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void step_double2()
         {
             TestUtils.AreEqual(double2(0.0, 0.0), step(double2(-123.45, -123.45), double2(double.NegativeInfinity, -200.0)));
@@ -2862,7 +2862,7 @@ public static void step_double2()
             TestUtils.AreEqual(double2(0.0, 0.0), step(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void step_double3()
         {
             TestUtils.AreEqual(double3(0.0, 0.0, 1.0), step(double3(-123.45, -123.45, -123.45), double3(double.NegativeInfinity, -200.0, 200.0)));
@@ -2876,7 +2876,7 @@ public static void step_double3()
             TestUtils.AreEqual(double3(0.0, 0.0, 0.0), step(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void step_double4()
         {
             TestUtils.AreEqual(double4(0.0, 0.0, 1.0, 1.0), step(double4(-123.45, -123.45, -123.45, -123.45), double4(double.NegativeInfinity, -200.0, 200.0, double.PositiveInfinity)));
@@ -2888,7 +2888,7 @@ public static void step_double4()
             TestUtils.AreEqual(double4(0.0, 0.0, 0.0, 0.0), step(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_int()
         {
             TestUtils.AreEqual(-2147483648, min(-2147483648, -2147483648));
@@ -2906,7 +2906,7 @@ public static void min_int()
             TestUtils.AreEqual(2147483647, min(2147483647, 2147483647));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_int2()
         {
             TestUtils.AreEqual(int2(-2147483648, -2147483648), min(int2(-2147483648, -2147483648), int2(-2147483648, -1)));
@@ -2918,7 +2918,7 @@ public static void min_int2()
             TestUtils.AreEqual(int2(2147483647, 2147483647), min(int2(2147483647, 2147483647), int2(2147483647, 2147483647)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_int3()
         {
             TestUtils.AreEqual(int3(-2147483648, -2147483648, -2147483648), min(int3(-2147483648, -2147483648, -1), int3(-2147483648, -1, -2147483648)));
@@ -2928,7 +2928,7 @@ public static void min_int3()
             TestUtils.AreEqual(int3(2147483647, 2147483647, 2147483647), min(int3(2147483647, 2147483647, 2147483647), int3(2147483647, 2147483647, 2147483647)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_int4()
         {
             TestUtils.AreEqual(int4(-2147483648, -2147483648, -2147483648, -3456), min(int4(-2147483648, -2147483648, -1, -1234), int4(-2147483648, -1, -2147483648, -3456)));
@@ -2937,7 +2937,7 @@ public static void min_int4()
             TestUtils.AreEqual(int4(2147483647, 2147483647, 2147483647, 2147483647), min(int4(2147483647, 2147483647, 2147483647, 2147483647), int4(2147483647, 2147483647, 2147483647, 2147483647)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_uint()
         {
             TestUtils.AreEqual(1234u, min(1234u, 3456u));
@@ -2949,7 +2949,7 @@ public static void min_uint()
             TestUtils.AreEqual(4294967295u, min(4294967295u, 4294967295u));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_uint2()
         {
             TestUtils.AreEqual(uint2(1234u, 1234u), min(uint2(1234u, 3456u), uint2(3456u, 1234u)));
@@ -2958,7 +2958,7 @@ public static void min_uint2()
             TestUtils.AreEqual(uint2(4294967295u, 4294967295u), min(uint2(4294967295u, 4294967295u), uint2(4294967295u, 4294967295u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_uint3()
         {
             TestUtils.AreEqual(uint3(1234u, 1234u, 7u), min(uint3(1234u, 3456u, 4294967040u), uint3(3456u, 1234u, 7u)));
@@ -2966,14 +2966,14 @@ public static void min_uint3()
             TestUtils.AreEqual(uint3(4294967295u, 4294967295u, 4294967295u), min(uint3(4294967295u, 4294967295u, 4294967295u), uint3(4294967295u, 4294967295u, 4294967295u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_uint4()
         {
             TestUtils.AreEqual(uint4(1234u, 1234u, 7u, 7u), min(uint4(1234u, 3456u, 4294967040u, 7u), uint4(3456u, 1234u, 7u, 4294967040u)));
             TestUtils.AreEqual(uint4(1u, 1u, 4294967295u, 4294967295u), min(uint4(1u, 4294967295u, 4294967295u, 4294967295u), uint4(4294967295u, 1u, 4294967295u, 4294967295u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_long()
         {
             TestUtils.AreEqual(-9223372036854775808L, min(-9223372036854775808L, -9223372036854775808L));
@@ -2991,7 +2991,7 @@ public static void min_long()
             TestUtils.AreEqual(9223372036854775807L, min(9223372036854775807L, 9223372036854775807L));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_ulong()
         {
             TestUtils.AreEqual(1234UL, min(1234UL, 3456UL));
@@ -3003,7 +3003,7 @@ public static void min_ulong()
             TestUtils.AreEqual(18446744073709551615UL, min(18446744073709551615UL, 18446744073709551615UL));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_float()
         {
             TestUtils.AreEqual(float.NegativeInfinity, min(float.NegativeInfinity, float.NegativeInfinity));
@@ -3024,7 +3024,7 @@ public static void min_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), min(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_float2()
         {
             TestUtils.AreEqual(float2(float.NegativeInfinity, float.NegativeInfinity), min(float2(float.NegativeInfinity, float.NegativeInfinity), float2(float.NegativeInfinity, -1f)));
@@ -3037,7 +3037,7 @@ public static void min_float2()
             TestUtils.AreEqual(float2(2.3f, TestUtils.SignedFloatQNaN()), min(float2(2.3f, TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_float3()
         {
             TestUtils.AreEqual(float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity), min(float3(float.NegativeInfinity, float.NegativeInfinity, -1f), float3(float.NegativeInfinity, -1f, float.NegativeInfinity)));
@@ -3048,7 +3048,7 @@ public static void min_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), min(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_float4()
         {
             TestUtils.AreEqual(float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, -3456.7f), min(float4(float.NegativeInfinity, float.NegativeInfinity, -1f, -1234.56f), float4(float.NegativeInfinity, -1f, float.NegativeInfinity, -3456.7f)));
@@ -3057,7 +3057,7 @@ public static void min_float4()
             TestUtils.AreEqual(float4(float.PositiveInfinity, 2.3f, 2.3f, TestUtils.SignedFloatQNaN()), min(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), 2.3f, TestUtils.SignedFloatQNaN()), float4(float.PositiveInfinity, 2.3f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_double()
         {
             TestUtils.AreEqual(double.NegativeInfinity, min(double.NegativeInfinity, double.NegativeInfinity));
@@ -3078,7 +3078,7 @@ public static void min_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), min(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_double2()
         {
             TestUtils.AreEqual(double2(double.NegativeInfinity, double.NegativeInfinity), min(double2(double.NegativeInfinity, double.NegativeInfinity), double2(double.NegativeInfinity, -1.0)));
@@ -3091,7 +3091,7 @@ public static void min_double2()
             TestUtils.AreEqual(double2(2.3, TestUtils.SignedDoubleQNaN()), min(double2(2.3, TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_double3()
         {
             TestUtils.AreEqual(double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity), min(double3(double.NegativeInfinity, double.NegativeInfinity, -1.0), double3(double.NegativeInfinity, -1.0, double.NegativeInfinity)));
@@ -3102,7 +3102,7 @@ public static void min_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), min(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void min_double4()
         {
             TestUtils.AreEqual(double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, -3456.7), min(double4(double.NegativeInfinity, double.NegativeInfinity, -1.0, -1234.56), double4(double.NegativeInfinity, -1.0, double.NegativeInfinity, -3456.7)));
@@ -3111,7 +3111,7 @@ public static void min_double4()
             TestUtils.AreEqual(double4(double.PositiveInfinity, 2.3, 2.3, TestUtils.SignedDoubleQNaN()), min(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), 2.3, TestUtils.SignedDoubleQNaN()), double4(double.PositiveInfinity, 2.3, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_int()
         {
             TestUtils.AreEqual(-2147483648, max(-2147483648, -2147483648));
@@ -3129,7 +3129,7 @@ public static void max_int()
             TestUtils.AreEqual(2147483647, max(2147483647, 2147483647));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_int2()
         {
             TestUtils.AreEqual(int2(-2147483648, -1), max(int2(-2147483648, -2147483648), int2(-2147483648, -1)));
@@ -3141,7 +3141,7 @@ public static void max_int2()
             TestUtils.AreEqual(int2(2147483647, 2147483647), max(int2(2147483647, 2147483647), int2(2147483647, 2147483647)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_int3()
         {
             TestUtils.AreEqual(int3(-2147483648, -1, -1), max(int3(-2147483648, -2147483648, -1), int3(-2147483648, -1, -2147483648)));
@@ -3151,7 +3151,7 @@ public static void max_int3()
             TestUtils.AreEqual(int3(2147483647, 2147483647, 2147483647), max(int3(2147483647, 2147483647, 2147483647), int3(2147483647, 2147483647, 2147483647)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_int4()
         {
             TestUtils.AreEqual(int4(-2147483648, -1, -1, -1234), max(int4(-2147483648, -2147483648, -1, -1234), int4(-2147483648, -1, -2147483648, -3456)));
@@ -3160,7 +3160,7 @@ public static void max_int4()
             TestUtils.AreEqual(int4(2147483647, 2147483647, 2147483647, 2147483647), max(int4(2147483647, 2147483647, 2147483647, 2147483647), int4(2147483647, 2147483647, 2147483647, 2147483647)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_uint()
         {
             TestUtils.AreEqual(3456u, max(1234u, 3456u));
@@ -3172,7 +3172,7 @@ public static void max_uint()
             TestUtils.AreEqual(4294967295u, max(4294967295u, 4294967295u));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_uint2()
         {
             TestUtils.AreEqual(uint2(3456u, 3456u), max(uint2(1234u, 3456u), uint2(3456u, 1234u)));
@@ -3181,7 +3181,7 @@ public static void max_uint2()
             TestUtils.AreEqual(uint2(4294967295u, 4294967295u), max(uint2(4294967295u, 4294967295u), uint2(4294967295u, 4294967295u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_uint3()
         {
             TestUtils.AreEqual(uint3(3456u, 3456u, 4294967040u), max(uint3(1234u, 3456u, 4294967040u), uint3(3456u, 1234u, 7u)));
@@ -3189,14 +3189,14 @@ public static void max_uint3()
             TestUtils.AreEqual(uint3(4294967295u, 4294967295u, 4294967295u), max(uint3(4294967295u, 4294967295u, 4294967295u), uint3(4294967295u, 4294967295u, 4294967295u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_uint4()
         {
             TestUtils.AreEqual(uint4(3456u, 3456u, 4294967040u, 4294967040u), max(uint4(1234u, 3456u, 4294967040u, 7u), uint4(3456u, 1234u, 7u, 4294967040u)));
             TestUtils.AreEqual(uint4(4294967295u, 4294967295u, 4294967295u, 4294967295u), max(uint4(1u, 4294967295u, 4294967295u, 4294967295u), uint4(4294967295u, 1u, 4294967295u, 4294967295u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_long()
         {
             TestUtils.AreEqual(-9223372036854775808L, max(-9223372036854775808L, -9223372036854775808L));
@@ -3214,7 +3214,7 @@ public static void max_long()
             TestUtils.AreEqual(9223372036854775807L, max(9223372036854775807L, 9223372036854775807L));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_ulong()
         {
             TestUtils.AreEqual(3456UL, max(1234UL, 3456UL));
@@ -3226,7 +3226,7 @@ public static void max_ulong()
             TestUtils.AreEqual(18446744073709551615UL, max(18446744073709551615UL, 18446744073709551615UL));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_float()
         {
             TestUtils.AreEqual(float.NegativeInfinity, max(float.NegativeInfinity, float.NegativeInfinity));
@@ -3247,7 +3247,7 @@ public static void max_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), max(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_float2()
         {
             TestUtils.AreEqual(float2(float.NegativeInfinity, -1f), max(float2(float.NegativeInfinity, float.NegativeInfinity), float2(float.NegativeInfinity, -1f)));
@@ -3260,7 +3260,7 @@ public static void max_float2()
             TestUtils.AreEqual(float2(2.3f, TestUtils.SignedFloatQNaN()), max(float2(2.3f, TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_float3()
         {
             TestUtils.AreEqual(float3(float.NegativeInfinity, -1f, -1f), max(float3(float.NegativeInfinity, float.NegativeInfinity, -1f), float3(float.NegativeInfinity, -1f, float.NegativeInfinity)));
@@ -3271,7 +3271,7 @@ public static void max_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), max(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_float4()
         {
             TestUtils.AreEqual(float4(float.NegativeInfinity, -1f, -1f, -1234.56f), max(float4(float.NegativeInfinity, float.NegativeInfinity, -1f, -1234.56f), float4(float.NegativeInfinity, -1f, float.NegativeInfinity, -3456.7f)));
@@ -3280,7 +3280,7 @@ public static void max_float4()
             TestUtils.AreEqual(float4(float.PositiveInfinity, 2.3f, 2.3f, TestUtils.SignedFloatQNaN()), max(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), 2.3f, TestUtils.SignedFloatQNaN()), float4(float.PositiveInfinity, 2.3f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_double()
         {
             TestUtils.AreEqual(double.NegativeInfinity, max(double.NegativeInfinity, double.NegativeInfinity));
@@ -3301,7 +3301,7 @@ public static void max_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), max(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_double2()
         {
             TestUtils.AreEqual(double2(double.NegativeInfinity, -1.0), max(double2(double.NegativeInfinity, double.NegativeInfinity), double2(double.NegativeInfinity, -1.0)));
@@ -3314,7 +3314,7 @@ public static void max_double2()
             TestUtils.AreEqual(double2(2.3, TestUtils.SignedDoubleQNaN()), max(double2(2.3, TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_double3()
         {
             TestUtils.AreEqual(double3(double.NegativeInfinity, -1.0, -1.0), max(double3(double.NegativeInfinity, double.NegativeInfinity, -1.0), double3(double.NegativeInfinity, -1.0, double.NegativeInfinity)));
@@ -3325,7 +3325,7 @@ public static void max_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), max(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void max_double4()
         {
             TestUtils.AreEqual(double4(double.NegativeInfinity, -1.0, -1.0, -1234.56), max(double4(double.NegativeInfinity, double.NegativeInfinity, -1.0, -1234.56), double4(double.NegativeInfinity, -1.0, double.NegativeInfinity, -3456.7)));
@@ -3334,7 +3334,7 @@ public static void max_double4()
             TestUtils.AreEqual(double4(double.PositiveInfinity, 2.3, 2.3, TestUtils.SignedDoubleQNaN()), max(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), 2.3, TestUtils.SignedDoubleQNaN()), double4(double.PositiveInfinity, 2.3, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void smoothstep_float()
         {
             TestUtils.AreEqual(0f, smoothstep(-123.45f, 345.6f, float.NegativeInfinity), 8, false);
@@ -3351,7 +3351,7 @@ public static void smoothstep_float()
             TestUtils.AreEqual(1f, smoothstep(345.6f, -123.45f, TestUtils.SignedFloatQNaN()), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void smoothstep_float2()
         {
             TestUtils.AreEqual(float2(0f, 0f), smoothstep(float2(-123.45f, -123.45f), float2(345.6f, 345.6f), float2(float.NegativeInfinity, -200f)), 8, false);
@@ -3362,7 +3362,7 @@ public static void smoothstep_float2()
             TestUtils.AreEqual(float2(0f, 1f), smoothstep(float2(345.6f, 345.6f), float2(-123.45f, -123.45f), float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN())), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void smoothstep_float3()
         {
             TestUtils.AreEqual(float3(0f, 0f, 0.00724848127f), smoothstep(float3(-123.45f, -123.45f, -123.45f), float3(345.6f, 345.6f, 345.6f), float3(float.NegativeInfinity, -200f, -100f)), 8, false);
@@ -3371,7 +3371,7 @@ public static void smoothstep_float3()
             TestUtils.AreEqual(float3(0f, 0f, 1f), smoothstep(float3(345.6f, 345.6f, 345.6f), float3(-123.45f, -123.45f, -123.45f), float3(400f, float.PositiveInfinity, TestUtils.SignedFloatQNaN())), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void smoothstep_float4()
         {
             TestUtils.AreEqual(float4(0f, 0f, 0.00724848127f, 1f), smoothstep(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(345.6f, 345.6f, 345.6f, 345.6f), float4(float.NegativeInfinity, -200f, -100f, 400f)), 8, false);
@@ -3379,7 +3379,7 @@ public static void smoothstep_float4()
             TestUtils.AreEqual(float4(0.992751539f, 0f, 0f, 1f), smoothstep(float4(345.6f, 345.6f, 345.6f, 345.6f), float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(-100f, 400f, float.PositiveInfinity, TestUtils.SignedFloatQNaN())), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void smoothstep_double()
         {
             TestUtils.AreEqual(0.0, smoothstep(-123.45, 345.6, double.NegativeInfinity), 8, false);
@@ -3396,7 +3396,7 @@ public static void smoothstep_double()
             TestUtils.AreEqual(1.0, smoothstep(345.6, -123.45, TestUtils.SignedDoubleQNaN()), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void smoothstep_double2()
         {
             TestUtils.AreEqual(double2(0.0, 0.0), smoothstep(double2(-123.45, -123.45), double2(345.6, 345.6), double2(double.NegativeInfinity, -200.0)), 8, false);
@@ -3407,7 +3407,7 @@ public static void smoothstep_double2()
             TestUtils.AreEqual(double2(0.0, 1.0), smoothstep(double2(345.6, 345.6), double2(-123.45, -123.45), double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN())), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void smoothstep_double3()
         {
             TestUtils.AreEqual(double3(0.0, 0.0, 0.0072484810488798995), smoothstep(double3(-123.45, -123.45, -123.45), double3(345.6, 345.6, 345.6), double3(double.NegativeInfinity, -200.0, -100.0)), 8, false);
@@ -3416,7 +3416,7 @@ public static void smoothstep_double3()
             TestUtils.AreEqual(double3(0.0, 0.0, 1.0), smoothstep(double3(345.6, 345.6, 345.6), double3(-123.45, -123.45, -123.45), double3(400.0, double.PositiveInfinity, TestUtils.SignedDoubleQNaN())), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void smoothstep_double4()
         {
             TestUtils.AreEqual(double4(0.0, 0.0, 0.0072484810488798995, 1.0), smoothstep(double4(-123.45, -123.45, -123.45, -123.45), double4(345.6, 345.6, 345.6, 345.6), double4(double.NegativeInfinity, -200.0, -100.0, 400.0)), 8, false);
@@ -3424,7 +3424,7 @@ public static void smoothstep_double4()
             TestUtils.AreEqual(double4(0.99275151895112013, 0.0, 0.0, 1.0), smoothstep(double4(345.6, 345.6, 345.6, 345.6), double4(-123.45, -123.45, -123.45, -123.45), double4(-100.0, 400.0, double.PositiveInfinity, TestUtils.SignedDoubleQNaN())), 8, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_int()
         {
             TestUtils.AreEqual(7097663, mad(1234, 5678, 91011));
@@ -3445,7 +3445,7 @@ public static void mad_int()
             TestUtils.AreEqual(1313707278, mad(-98765, -56789, -91011));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_int2()
         {
             TestUtils.AreEqual(int2(7097663, 6915641), mad(int2(1234, 1234), int2(5678, 5678), int2(91011, -91011)));
@@ -3458,7 +3458,7 @@ public static void mad_int2()
             TestUtils.AreEqual(int2(1313889300, 1313707278), mad(int2(-98765, -98765), int2(-56789, -56789), int2(91011, -91011)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_int3()
         {
             TestUtils.AreEqual(int3(7097663, 6915641, -6915641), mad(int3(1234, 1234, 1234), int3(5678, 5678, -5678), int3(91011, -91011, 91011)));
@@ -3469,7 +3469,7 @@ public static void mad_int3()
             TestUtils.AreEqual(int3(1313707278, 1313707278, 1313707278), mad(int3(-98765, -98765, -98765), int3(-56789, -56789, -56789), int3(-91011, -91011, -91011)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_int4()
         {
             TestUtils.AreEqual(int4(7097663, 6915641, -6915641, -7097663), mad(int4(1234, 1234, 1234, 1234), int4(5678, 5678, -5678, -5678), int4(91011, -91011, 91011, -91011)));
@@ -3478,32 +3478,32 @@ public static void mad_int4()
             TestUtils.AreEqual(int4(-1313707278, -1313889300, 1313889300, 1313707278), mad(int4(-98765, -98765, -98765, -98765), int4(56789, 56789, -56789, -56789), int4(91011, -91011, 91011, -91011)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_uint()
         {
             TestUtils.AreEqual(7097663u, mad(1234u, 5678u, 91011u));
             TestUtils.AreEqual(1313889300u, mad(98765u, 56789u, 91011u));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_uint2()
         {
             TestUtils.AreEqual(uint2(7097663u, 1313889300u), mad(uint2(1234u, 98765u), uint2(5678u, 56789u), uint2(91011u, 91011u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_uint3()
         {
             TestUtils.AreEqual(uint3(7097663u, 1313889300u, 1313889300u), mad(uint3(1234u, 98765u, 98765u), uint3(5678u, 56789u, 56789u), uint3(91011u, 91011u, 91011u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_uint4()
         {
             TestUtils.AreEqual(uint4(7097663u, 1313889300u, 1313889300u, 1313889300u), mad(uint4(1234u, 98765u, 98765u, 98765u), uint4(5678u, 56789u, 56789u, 56789u), uint4(91011u, 91011u, 91011u, 91011u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_long()
         {
             TestUtils.AreEqual(7097663L, mad(1234L, 5678L, 91011L));
@@ -3524,14 +3524,14 @@ public static void mad_long()
             TestUtils.AreEqual(747681192693554158L, mad(-9876543210L, -5678901234L, -9101112134L));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_ulong()
         {
             TestUtils.AreEqual(7097663L, mad(1234UL, 5678UL, 91011UL));
             TestUtils.AreEqual(747681210895778426L, mad(9876543210UL, 5678901234UL, 9101112134UL));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_float()
         {
             TestUtils.AreEqual(-42660f, mad(-123.45f, 345.6f, 4.321f), 1, false);
@@ -3540,27 +3540,27 @@ public static void mad_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), mad(-123.45f, 345.6f, TestUtils.SignedFloatQNaN()), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_float2()
         {
             TestUtils.AreEqual(float2(-42660f, TestUtils.SignedFloatQNaN()), mad(float2(-123.45f, TestUtils.SignedFloatQNaN()), float2(345.6f, 345.6f), float2(4.321f, 4.321f)), 1, false);
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), mad(float2(-123.45f, -123.45f), float2(TestUtils.SignedFloatQNaN(), 345.6f), float2(4.321f, TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_float3()
         {
             TestUtils.AreEqual(float3(-42660f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), mad(float3(-123.45f, TestUtils.SignedFloatQNaN(), -123.45f), float3(345.6f, 345.6f, TestUtils.SignedFloatQNaN()), float3(4.321f, 4.321f, 4.321f)), 1, false);
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), mad(float3(-123.45f, -123.45f, -123.45f), float3(345.6f, 345.6f, 345.6f), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_float4()
         {
             TestUtils.AreEqual(float4(-42660f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), mad(float4(-123.45f, TestUtils.SignedFloatQNaN(), -123.45f, -123.45f), float4(345.6f, 345.6f, TestUtils.SignedFloatQNaN(), 345.6f), float4(4.321f, 4.321f, 4.321f, TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_double()
         {
             TestUtils.AreEqual(-42659.999, mad(-123.45, 345.6, 4.321), 1, false);
@@ -3569,27 +3569,27 @@ public static void mad_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), mad(-123.45, 345.6, TestUtils.SignedDoubleQNaN()), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_double2()
         {
             TestUtils.AreEqual(double2(-42659.999, TestUtils.SignedDoubleQNaN()), mad(double2(-123.45, TestUtils.SignedDoubleQNaN()), double2(345.6, 345.6), double2(4.321, 4.321)), 1, false);
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), mad(double2(-123.45, -123.45), double2(TestUtils.SignedDoubleQNaN(), 345.6), double2(4.321, TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_double3()
         {
             TestUtils.AreEqual(double3(-42659.999, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), mad(double3(-123.45, TestUtils.SignedDoubleQNaN(), -123.45), double3(345.6, 345.6, TestUtils.SignedDoubleQNaN()), double3(4.321, 4.321, 4.321)), 1, false);
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), mad(double3(-123.45, -123.45, -123.45), double3(345.6, 345.6, 345.6), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void mad_double4()
         {
             TestUtils.AreEqual(double4(-42659.999, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), mad(double4(-123.45, TestUtils.SignedDoubleQNaN(), -123.45, -123.45), double4(345.6, 345.6, TestUtils.SignedDoubleQNaN(), 345.6), double4(4.321, 4.321, 4.321, TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void fmod_float()
         {
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), fmod(float.NegativeInfinity, float.NegativeInfinity), 1, false);
@@ -3643,7 +3643,7 @@ public static void fmod_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), fmod(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void fmod_float2()
         {
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), -323.4f), fmod(float2(float.NegativeInfinity, -323.4f), float2(float.NegativeInfinity, float.NegativeInfinity)), 1, false);
@@ -3673,7 +3673,7 @@ public static void fmod_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), fmod(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void fmod_float3()
         {
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), -323.4f, TestUtils.SignedFloatZero()), fmod(float3(float.NegativeInfinity, -323.4f, TestUtils.SignedFloatZero()), float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), 1, false);
@@ -3695,7 +3695,7 @@ public static void fmod_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), fmod(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void fmod_float4()
         {
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), -323.4f, TestUtils.SignedFloatZero(), 0f), fmod(float4(float.NegativeInfinity, -323.4f, TestUtils.SignedFloatZero(), 0f), float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), 1, false);
@@ -3713,7 +3713,7 @@ public static void fmod_float4()
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), fmod(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void fmod_double()
         {
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), fmod(double.NegativeInfinity, double.NegativeInfinity), 1, false);
@@ -3767,7 +3767,7 @@ public static void fmod_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), fmod(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void fmod_double2()
         {
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), -323.4), fmod(double2(double.NegativeInfinity, -323.4), double2(double.NegativeInfinity, double.NegativeInfinity)), 1, false);
@@ -3797,7 +3797,7 @@ public static void fmod_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), fmod(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void fmod_double3()
         {
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), -323.4, TestUtils.SignedDoubleZero()), fmod(double3(double.NegativeInfinity, -323.4, TestUtils.SignedDoubleZero()), double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), 1, false);
@@ -3819,7 +3819,7 @@ public static void fmod_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), fmod(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void fmod_double4()
         {
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), -323.4, TestUtils.SignedDoubleZero(), 0.0), fmod(double4(double.NegativeInfinity, -323.4, TestUtils.SignedDoubleZero(), 0.0), double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), 1, false);
@@ -3837,7 +3837,7 @@ public static void fmod_double4()
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), fmod(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void pow_float()
         {
             TestUtils.AreEqual(0f, pow(float.NegativeInfinity, float.NegativeInfinity), 1, false);
@@ -3887,7 +3887,7 @@ public static void pow_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), pow(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void pow_float2()
         {
             TestUtils.AreEqual(float2(0f, 0f), pow(float2(float.NegativeInfinity, -3.4f), float2(float.NegativeInfinity, float.NegativeInfinity)), 1, false);
@@ -3915,7 +3915,7 @@ public static void pow_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), pow(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void pow_float3()
         {
             TestUtils.AreEqual(float3(0f, 0f, float.PositiveInfinity), pow(float3(float.NegativeInfinity, -3.4f, TestUtils.SignedFloatZero()), float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), 1, false);
@@ -3935,7 +3935,7 @@ public static void pow_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), pow(float3(3.4f, float.PositiveInfinity, TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void pow_float4()
         {
             TestUtils.AreEqual(float4(0f, 0f, float.PositiveInfinity, float.PositiveInfinity), pow(float4(float.NegativeInfinity, -3.4f, TestUtils.SignedFloatZero(), 0f), float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), 1, false);
@@ -3952,7 +3952,7 @@ public static void pow_float4()
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), pow(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void pow_double()
         {
             TestUtils.AreEqual(0.0, pow(double.NegativeInfinity, double.NegativeInfinity), 1, false);
@@ -4002,7 +4002,7 @@ public static void pow_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), pow(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void pow_double2()
         {
             TestUtils.AreEqual(double2(0.0, 0.0), pow(double2(double.NegativeInfinity, -3.4), double2(double.NegativeInfinity, double.NegativeInfinity)), 1, false);
@@ -4030,7 +4030,7 @@ public static void pow_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), pow(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void pow_double3()
         {
             TestUtils.AreEqual(double3(0.0, 0.0, double.PositiveInfinity), pow(double3(double.NegativeInfinity, -3.4, TestUtils.SignedDoubleZero()), double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), 1, false);
@@ -4050,7 +4050,7 @@ public static void pow_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), pow(double3(3.4, double.PositiveInfinity, TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void pow_double4()
         {
             TestUtils.AreEqual(double4(0.0, 0.0, double.PositiveInfinity, double.PositiveInfinity), pow(double4(double.NegativeInfinity, -3.4, TestUtils.SignedDoubleZero(), 0.0), double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), 1, false);
@@ -4067,7 +4067,7 @@ public static void pow_double4()
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), pow(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceilpow2_int()
         {
             TestUtils.AreEqual(0, ceilpow2(0));
@@ -4079,7 +4079,7 @@ public static void ceilpow2_int()
             TestUtils.AreEqual(0, ceilpow2(-2147483647));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceilpow2_int2()
         {
             TestUtils.AreEqual(int2(0, 1), ceilpow2(int2(0, 1)));
@@ -4088,7 +4088,7 @@ public static void ceilpow2_int2()
             TestUtils.AreEqual(int2(0, 0), ceilpow2(int2(-2147483647, -2147483647)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceilpow2_int3()
         {
             TestUtils.AreEqual(int3(0, 1, 2), ceilpow2(int3(0, 1, 2)));
@@ -4096,14 +4096,14 @@ public static void ceilpow2_int3()
             TestUtils.AreEqual(int3(0, 0, 0), ceilpow2(int3(-2147483647, -2147483647, -2147483647)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceilpow2_int4()
         {
             TestUtils.AreEqual(int4(0, 1, 2, 4), ceilpow2(int4(0, 1, 2, 3)));
             TestUtils.AreEqual(int4(1073741824, -2147483648, 0, 0), ceilpow2(int4(1019642234, 1823423423, -2147483647, -2147483647)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceilpow2_uint()
         {
             TestUtils.AreEqual(0u, ceilpow2(0u));
@@ -4115,7 +4115,7 @@ public static void ceilpow2_uint()
             TestUtils.AreEqual(0u, ceilpow2(4294967295u));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceilpow2_uint2()
         {
             TestUtils.AreEqual(uint2(0u, 1u), ceilpow2(uint2(0u, 1u)));
@@ -4124,7 +4124,7 @@ public static void ceilpow2_uint2()
             TestUtils.AreEqual(uint2(0u, 0u), ceilpow2(uint2(4294967295u, 4294967295u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceilpow2_uint3()
         {
             TestUtils.AreEqual(uint3(0u, 1u, 2u), ceilpow2(uint3(0u, 1u, 2u)));
@@ -4132,14 +4132,14 @@ public static void ceilpow2_uint3()
             TestUtils.AreEqual(uint3(0u, 0u, 0u), ceilpow2(uint3(4294967295u, 4294967295u, 4294967295u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceilpow2_uint4()
         {
             TestUtils.AreEqual(uint4(0u, 1u, 2u, 4u), ceilpow2(uint4(0u, 1u, 2u, 3u)));
             TestUtils.AreEqual(uint4(1073741824u, 2147483648u, 0u, 0u), ceilpow2(uint4(1019642234u, 1823423423u, 4294967295u, 4294967295u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceilpow2_long()
         {
             TestUtils.AreEqual(0L, ceilpow2(0L));
@@ -4155,7 +4155,7 @@ public static void ceilpow2_long()
             TestUtils.AreEqual(0L, ceilpow2(-100L));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceilpow2_ulong()
         {
             TestUtils.AreEqual(0UL, ceilpow2(0UL));
@@ -4171,7 +4171,7 @@ public static void ceilpow2_ulong()
             TestUtils.AreEqual(0UL, ceilpow2(10223372036854775808UL));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void floorlog2_int()
         {
             TestUtils.AreEqual(0, floorlog2(1));
@@ -4185,7 +4185,7 @@ public static void floorlog2_int()
             TestUtils.AreEqual(30, floorlog2(2147483647));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void floorlog2_int2()
         {
             TestUtils.AreEqual(int2(0, 1), floorlog2(int2(1, 2)));
@@ -4195,7 +4195,7 @@ public static void floorlog2_int2()
             TestUtils.AreEqual(int2(30, 30), floorlog2(int2(2147483647, 2147483647)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void floorlog2_int3()
         {
             TestUtils.AreEqual(int3(0, 1, 1), floorlog2(int3(1, 2, 3)));
@@ -4203,7 +4203,7 @@ public static void floorlog2_int3()
             TestUtils.AreEqual(int3(15, 15, 30), floorlog2(int3(32768, 32769, 2147483647)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void floorlog2_int4()
         {
             TestUtils.AreEqual(int4(0, 1, 1, 2), floorlog2(int4(1, 2, 3, 4)));
@@ -4211,7 +4211,7 @@ public static void floorlog2_int4()
             TestUtils.AreEqual(int4(30, 30, 30, 30), floorlog2(int4(2147483647, 2147483647, 2147483647, 2147483647)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void floorlog2_uint()
         {
             TestUtils.AreEqual(0, floorlog2(1u));
@@ -4225,7 +4225,7 @@ public static void floorlog2_uint()
             TestUtils.AreEqual(30, floorlog2(2147483647u));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void floorlog2_uint2()
         {
             TestUtils.AreEqual(int2(0, 1), floorlog2(uint2(1u, 2u)));
@@ -4235,7 +4235,7 @@ public static void floorlog2_uint2()
             TestUtils.AreEqual(int2(30, 30), floorlog2(uint2(2147483647u, 2147483647u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void floorlog2_uint3()
         {
             TestUtils.AreEqual(int3(0, 1, 1), floorlog2(uint3(1u, 2u, 3u)));
@@ -4243,7 +4243,7 @@ public static void floorlog2_uint3()
             TestUtils.AreEqual(int3(15, 15, 30), floorlog2(uint3(32768u, 32769u, 2147483647u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void floorlog2_uint4()
         {
             TestUtils.AreEqual(int4(0, 1, 1, 2), floorlog2(uint4(1u, 2u, 3u, 4u)));
@@ -4251,7 +4251,7 @@ public static void floorlog2_uint4()
             TestUtils.AreEqual(int4(30, 30, 30, 30), floorlog2(uint4(2147483647u, 2147483647u, 2147483647u, 2147483647u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceillog2_int()
         {
             TestUtils.AreEqual(0, ceillog2(1));
@@ -4269,7 +4269,7 @@ public static void ceillog2_int()
             TestUtils.AreEqual(31, ceillog2(2147483647));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceillog2_int2()
         {
             TestUtils.AreEqual(int2(0, 1), ceillog2(int2(1, 2)));
@@ -4281,7 +4281,7 @@ public static void ceillog2_int2()
             TestUtils.AreEqual(int2(31, 31), ceillog2(int2(2147483647, 2147483647)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceillog2_int3()
         {
             TestUtils.AreEqual(int3(0, 1, 2), ceillog2(int3(1, 2, 3)));
@@ -4291,7 +4291,7 @@ public static void ceillog2_int3()
             TestUtils.AreEqual(int3(31, 31, 31), ceillog2(int3(2147483647, 2147483647, 2147483647)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceillog2_int4()
         {
             TestUtils.AreEqual(int4(0, 1, 2, 2), ceillog2(int4(1, 2, 3, 4)));
@@ -4300,7 +4300,7 @@ public static void ceillog2_int4()
             TestUtils.AreEqual(int4(31, 31, 31, 31), ceillog2(int4(2147483647, 2147483647, 2147483647, 2147483647)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceillog2_uint()
         {
             TestUtils.AreEqual(0, ceillog2(1u));
@@ -4318,7 +4318,7 @@ public static void ceillog2_uint()
             TestUtils.AreEqual(32, ceillog2(4294967295u));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceillog2_uint2()
         {
             TestUtils.AreEqual(int2(0, 1), ceillog2(uint2(1u, 2u)));
@@ -4330,7 +4330,7 @@ public static void ceillog2_uint2()
             TestUtils.AreEqual(int2(32, 32), ceillog2(uint2(4294967295u, 4294967295u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceillog2_uint3()
         {
             TestUtils.AreEqual(int3(0, 1, 2), ceillog2(uint3(1u, 2u, 3u)));
@@ -4340,7 +4340,7 @@ public static void ceillog2_uint3()
             TestUtils.AreEqual(int3(32, 32, 32), ceillog2(uint3(4294967295u, 4294967295u, 4294967295u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ceillog2_uint4()
         {
             TestUtils.AreEqual(int4(0, 1, 2, 2), ceillog2(uint4(1u, 2u, 3u, 4u)));
@@ -4349,7 +4349,7 @@ public static void ceillog2_uint4()
             TestUtils.AreEqual(int4(32, 32, 32, 32), ceillog2(uint4(4294967295u, 4294967295u, 4294967295u, 4294967295u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ispow2_int()
         {
             TestUtils.AreEqual(false, ispow2(-3));
@@ -4368,7 +4368,7 @@ public static void ispow2_int()
             TestUtils.AreEqual(false, ispow2(268431360));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ispow2_int2()
         {
             TestUtils.AreEqual(bool2(false, false), ispow2(int2(-3, -2)));
@@ -4380,7 +4380,7 @@ public static void ispow2_int2()
             TestUtils.AreEqual(bool2(true, false), ispow2(int2(2097152, 268431360)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ispow2_int3()
         {
             TestUtils.AreEqual(bool3(false, false, false), ispow2(int3(-3, -2, -1)));
@@ -4390,7 +4390,7 @@ public static void ispow2_int3()
             TestUtils.AreEqual(bool3(true, false, false), ispow2(int3(2097152, 268431360, 268431360)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ispow2_int4()
         {
             TestUtils.AreEqual(bool4(false, false, false, false), ispow2(int4(-3, -2, -1, 0)));
@@ -4399,7 +4399,7 @@ public static void ispow2_int4()
             TestUtils.AreEqual(bool4(true, false, false, false), ispow2(int4(2097152, 268431360, 268431360, 268431360)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ispow2_uint()
         {
             TestUtils.AreEqual(false, ispow2(0u));
@@ -4416,7 +4416,7 @@ public static void ispow2_uint()
             TestUtils.AreEqual(false, ispow2(268431360u));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ispow2_uint2()
         {
             TestUtils.AreEqual(bool2(false, true), ispow2(uint2(0u, 1u)));
@@ -4427,7 +4427,7 @@ public static void ispow2_uint2()
             TestUtils.AreEqual(bool2(false, false), ispow2(uint2(2097153u, 268431360u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ispow2_uint3()
         {
             TestUtils.AreEqual(bool3(false, true, true), ispow2(uint3(0u, 1u, 2u)));
@@ -4436,7 +4436,7 @@ public static void ispow2_uint3()
             TestUtils.AreEqual(bool3(true, false, false), ispow2(uint3(2097152u, 2097153u, 268431360u)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ispow2_uint4()
         {
             TestUtils.AreEqual(bool4(false, true, true, false), ispow2(uint4(0u, 1u, 2u, 3u)));
diff --git a/src/Tests/Tests/Shared/TestMatrix.cs b/src/Tests/Tests/Shared/TestMatrix.cs
index 558ce482..5fc6a37b 100644
--- a/src/Tests/Tests/Shared/TestMatrix.cs
+++ b/src/Tests/Tests/Shared/TestMatrix.cs
@@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     class TestMatrix
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_constructor_columns()
         {
             float2x2 a = float2x2(float2(1.0f, 2.0f),
@@ -19,7 +19,7 @@ public static void float2x2_constructor_columns()
             TestUtils.AreEqual(4.0f, a.c1.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_constructor_columns()
         {
             float3x3 a = float3x3(float3(1.0f, 2.0f, 3.0f),
@@ -37,7 +37,7 @@ public static void float3x3_constructor_columns()
             TestUtils.AreEqual(9.0f, a.c2.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_constructor_columns()
         {
             float4x4 a = float4x4(float4( 1.0f,  2.0f,  3.0f,  4.0f),
@@ -63,7 +63,7 @@ public static void float4x4_constructor_columns()
             TestUtils.AreEqual(16.0f, a.c3.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_constructor_scalars()
         {
             float2x2 a = float2x2(1.0f, 2.0f,
@@ -75,7 +75,7 @@ public static void float2x2_constructor_scalars()
             TestUtils.AreEqual(4.0f, a.c1.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_constructor_scalars()
         {
             float3x3 a = float3x3(1.0f, 2.0f, 3.0f,
@@ -93,7 +93,7 @@ public static void float3x3_constructor_scalars()
             TestUtils.AreEqual(9.0f, a.c2.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_constructor_scalars()
         {
             float4x4 a = float4x4( 1.0f,  2.0f,  3.0f,  4.0f,
@@ -119,7 +119,7 @@ public static void float4x4_constructor_scalars()
             TestUtils.AreEqual(16.0f, a.c3.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_constructor_float3x3()
         {
             float3x3 rot = float3x3(1.0f, 2.0f, 3.0f,
@@ -136,7 +136,7 @@ public static void float4x4_constructor_float3x3()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_constructor_quaternion()
         {
             float3x3 m = float3x3(normalize(quaternion(1.0f, 2.5f, 3.3f, 4.6f)));
@@ -148,7 +148,7 @@ public static void float3x3_constructor_quaternion()
             TestUtils.AreEqual(r, m, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_constructor_quaternion_position()
         {
             float4x4 m = float4x4(normalize(quaternion(1.0f, 2.5f, 3.3f, 4.6f)), float3(1.0f, 2.0f, 3.0f));
@@ -161,7 +161,7 @@ public static void float4x4_constructor_quaternion_position()
             TestUtils.AreEqual(r, m, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_identity()
         {
             float2x2 a = float2x2.identity;
@@ -171,7 +171,7 @@ public static void float2x2_identity()
             TestUtils.AreEqual(1.0f, a.c1.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_identity()
         {
             float3x3 a = float3x3.identity;
@@ -186,7 +186,7 @@ public static void float3x3_identity()
             TestUtils.AreEqual(1.0f, a.c2.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_identity()
         {
             float4x4 a = float4x4.identity;
@@ -208,7 +208,7 @@ public static void float4x4_identity()
             TestUtils.AreEqual(1.0f, a.c3.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_rotate()
         {
             float epsilon = 0.0001f;
@@ -220,7 +220,7 @@ public static void float2x2_rotate()
             TestUtils.AreEqual(cos(angle), m.c1.y, epsilon);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_axis_angle()
         {
             float3 axis = normalize(float3(1.1f, 2.3f, -3.6f));
@@ -231,7 +231,7 @@ public static void float3x3_axis_angle()
             TestUtils.AreEqual(r, m, 0.00001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_axis_angle_consistency()
         {
             TestUtils.AreEqual(float3x3.RotateX(1.0f), float3x3.AxisAngle(float3(1, 0, 0), 1.0f), 0.001f);
@@ -239,7 +239,7 @@ public static void float3x3_axis_angle_consistency()
             TestUtils.AreEqual(float3x3.RotateZ(1.0f), float3x3.AxisAngle(float3(0, 0, 1), 1.0f), 0.001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_rotate_x()
         {
             float epsilon = 0.0001f;
@@ -256,7 +256,7 @@ public static void float3x3_rotate_x()
             TestUtils.AreEqual(cos(angle), m.c2.z, epsilon);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_rotate_y()
         {
             float epsilon = 0.0001f;
@@ -273,7 +273,7 @@ public static void float3x3_rotate_y()
             TestUtils.AreEqual(cos(angle), m.c2.z, epsilon);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_rotate_z()
         {
             float epsilon = 0.0001f;
@@ -290,7 +290,7 @@ public static void float3x3_rotate_z()
             TestUtils.AreEqual(1.0f, m.c2.z, epsilon);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_rotate_x_handedness()
         {
             float3 a = float3(0.0f, 0.3f, 0.7f);
@@ -301,7 +301,7 @@ public static void float3x3_rotate_x_handedness()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_rotate_y_handedness()
         {
             float3 a = float3(0.3f, 0.0f, 0.7f);
@@ -311,7 +311,7 @@ public static void float3x3_rotate_y_handedness()
             TestUtils.AreEqual(w > 0.0f, true);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_rotate_z_handedness()
         {
             float3 a = float3(0.3f, 0.7f, 0.0f);
@@ -321,7 +321,7 @@ public static void float3x3_rotate_z_handedness()
             TestUtils.AreEqual(w > 0.0f, true);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_axis_angle()
         {
             float3 axis = normalize(float3(1.1f, 2.3f, -3.6f));
@@ -332,7 +332,7 @@ public static void float4x4_axis_angle()
             TestUtils.AreEqual(r, m, 0.00001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_axis_angle_consistency()
         {
             TestUtils.AreEqual(float4x4.RotateX(1.0f), float4x4.AxisAngle(float3(1, 0, 0), 1.0f), 0.001f);
@@ -340,7 +340,7 @@ public static void float4x4_axis_angle_consistency()
             TestUtils.AreEqual(float4x4.RotateZ(1.0f), float4x4.AxisAngle(float3(0, 0, 1), 1.0f), 0.001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_rotate_x()
         {
             float epsilon = 0.0001f;
@@ -364,7 +364,7 @@ public static void float4x4_rotate_x()
             TestUtils.AreEqual(1.0f, m.c3.w, epsilon);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_rotate_y()
         {
             float epsilon = 0.0001f;
@@ -388,7 +388,7 @@ public static void float4x4_rotate_y()
             TestUtils.AreEqual(1.0f, m.c3.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_rotate_z()
         {
             float epsilon = 0.0001f;
@@ -412,7 +412,7 @@ public static void float4x4_rotate_z()
             TestUtils.AreEqual(1.0f, m.c3.w, epsilon);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_rotate_x_handedness()
         {
             float3 a = float3(0.0f, 0.3f, 0.7f);
@@ -423,7 +423,7 @@ public static void float4x4_rotate_x_handedness()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_rotate_y_handedness()
         {
             float3 a = float3(0.3f, 0.0f, 0.7f);
@@ -433,7 +433,7 @@ public static void float4x4_rotate_y_handedness()
             TestUtils.AreEqual(w > 0.0f, true);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_rotate_z_handedness()
         {
             float3 a = float3(0.3f, 0.7f, 0.0f);
@@ -480,7 +480,7 @@ public static void float4x4_rotate_z_handedness()
         static internal readonly float4x4 test4x4_zyx = new float4x4(test3x3_zyx, new float3(0, 0, 0));
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_euler()
         {
             float3x3 m0_xyz = float3x3.EulerXYZ(test_angles);
@@ -547,7 +547,7 @@ public static void float3x3_euler()
             TestUtils.AreEqual(test3x3_zyx, m3_zyx, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_euler()
         {
             float4x4 m0_xyz = float4x4.EulerXYZ(test_angles);
@@ -614,7 +614,7 @@ public static void float4x4_euler()
             TestUtils.AreEqual(test4x4_zyx, m3_zyx, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_scale()
         {
             float2x2 m = float2x2(1.0f, 2.0f,
@@ -635,7 +635,7 @@ public static void float2x2_scale()
             TestUtils.AreEqual(r1, c);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_scale()
         {
             float3x3 m = float3x3(1.0f, 2.0f, 3.0f,
@@ -661,7 +661,7 @@ public static void float3x3_scale()
             TestUtils.AreEqual(r1, c);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_scale()
         {
             float4x4 m = float4x4( 1.0f,  2.0f,  3.0f,  4.0f,
@@ -688,7 +688,7 @@ public static void float4x4_scale()
             TestUtils.AreEqual(r1, c);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_matrix_mul()
         {
             // http://www.wolframalpha.com/input/?i=%5B%5B1,2%5D,%5B3,4%5D%5D*%5B%5B21,22%5D,%5B23,24%5D%5D
@@ -706,7 +706,7 @@ public static void float2x2_matrix_mul()
             TestUtils.AreEqual(162.0f, c.c1.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_matrix_mul()
         {
             // http://www.wolframalpha.com/input/?i=%5B%5B1,2,3%5D,%5B4,5,6%5D,%5B7,8,9%5D%5D*%5B%5B21,22,23%5D,%5B24,25,26%5D,%5B27,28,29%5D%5D
@@ -732,7 +732,7 @@ public static void float3x3_matrix_mul()
             TestUtils.AreEqual(630.0f, c.c2.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_matrix_mul()
         {
             // https://fogbugz.unity3d.com/f/cases/1041176/
@@ -769,7 +769,7 @@ public static void float4x4_matrix_mul()
             TestUtils.AreEqual(1760.0f, c.c3.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_transpose()
         {
             float2x2 a = float2x2(1.0f, 2.0f,
@@ -783,7 +783,7 @@ public static void float2x2_transpose()
             TestUtils.AreEqual(4.0f, b.c1.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_transpose()
         {
             float3x3 a = float3x3(1.0f, 2.0f, 3.0f,
@@ -803,7 +803,7 @@ public static void float3x3_transpose()
             TestUtils.AreEqual(9.0f, b.c2.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_transpose()
         {
             float4x4 a = float4x4( 1.0f,  2.0f,  3.0f,  4.0f,
@@ -831,7 +831,7 @@ public static void float4x4_transpose()
             TestUtils.AreEqual(16.0f, b.c3.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_inverse()
         {
             float2x2 a = float2x2( 0.542968f,  0.867379f,
@@ -850,7 +850,7 @@ public static void float2x2_inverse()
             TestUtils.AreEqual(r.c1.y, invA.c1.y, epsilon);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_inverse()
         {
             float3x3 a = float3x3( 0.542968f, 0.867379f, 0.526616f,
@@ -877,7 +877,7 @@ public static void float3x3_inverse()
             TestUtils.AreEqual(r.c2.z, invA.c2.z, epsilon);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_inverse()
         {
             float4x4 a = float4x4( 0.542968f, 0.867379f, 0.526616f,-0.943083f,
@@ -914,7 +914,7 @@ public static void float4x4_inverse()
             TestUtils.AreEqual(r.c3.w, invA.c3.w, epsilon);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x4_fastinverse()
         {
             float4x4 a = test4x4_xyz;
@@ -931,7 +931,7 @@ public static void float3x4_fastinverse()
             TestUtils.AreEqual(invA.c3.xyz, fastInvB.c3.xyz, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_fastinverse()
         {
             float4x4 a = test4x4_xyz;
@@ -943,7 +943,7 @@ public static void float4x4_fastinverse()
             TestUtils.AreEqual(invA, fastInvA, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2x2_determinant()
         {
             float2x2 a = float2x2(0.542968f, 0.867379f,
@@ -953,7 +953,7 @@ public static void float2x2_determinant()
             TestUtils.AreEqual(-0.2610378f, det, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_determinant()
         {
             float3x3 a = float3x3( 0.542968f,  0.867379f, 0.526616f,
@@ -964,7 +964,7 @@ public static void float3x3_determinant()
             TestUtils.AreEqual(0.06019618f, det, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_determinant()
         {
             float4x4 a = float4x4( 0.542968f,  0.867379f, 0.526616f, -0.943083f,
@@ -976,7 +976,7 @@ public static void float4x4_determinant()
             TestUtils.AreEqual(0.5838502f, det, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_look_rotation()
         {
             float3 forward0 = normalize(float3(1.0f, 2.0f, 3.0f));
@@ -1012,7 +1012,7 @@ public static void float3x3_look_rotation()
             TestUtils.AreEqual(float3x3(quaternion.LookRotation(forward3, up3)), m3, 0.001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_look_rotation_safe()
         {
             float3 forward0 = float3(-3.2f, 2.3f, -1.3f) * 1e-10f;
@@ -1029,7 +1029,7 @@ public static void float3x3_look_rotation_safe()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_lookat()
         {
             float4x4 m = float4x4.LookAt(float3(0.3f, -0.5f, 3.0f), float3(3.2f, -3.1f, 0.2f), normalize(float3(0.3f, 1.0f, -3.0f)));
@@ -1043,7 +1043,7 @@ public static void float4x4_lookat()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_ortho()
         {
             float4x4 m = float4x4.Ortho(2.0f, 3.0f, -3.0f, 7.0f);
@@ -1056,7 +1056,7 @@ public static void float4x4_ortho()
             TestUtils.AreEqual(r, m, 0.001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_orthoOffCenter()
         {
             float4x4 m = float4x4.OrthoOffCenter(-2.0f, 1.0f, -3.0f, -1.0f, -3.0f, 7.0f);
@@ -1069,7 +1069,7 @@ public static void float4x4_orthoOffCenter()
             TestUtils.AreEqual(r, m, 0.001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_perspective()
         {
             float fovy = 1.6f;
@@ -1098,7 +1098,7 @@ public static void float4x4_perspective()
             TestUtils.AreEqual(float3(1.0f, 1.0f, 1.0f), pp1.xyz, 0.001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_perspectiveOffCenter()
         {
             float fovy = 1.6f;
@@ -1132,7 +1132,7 @@ public static void float4x4_perspectiveOffCenter()
             TestUtils.AreEqual(float3(-1.0f,  1.0f, 1.0f), pp2.xyz, 0.001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4x4_TRS()
         {
             float3 scale = float3(1.2f, -0.4f, 2.3f);
@@ -1143,7 +1143,7 @@ public static void float4x4_TRS()
             TestUtils.AreEqual(r0, m0, 0.001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_constructor_float4x4()
         {
             var f4x4 = new float4x4(new float4(1, 2, 3, 4), new float4(5, 6, 7, 8), new float4(9, 10, 11, 12), new float4(13, 14, 15, 16));
@@ -1152,7 +1152,7 @@ public static void float3x3_constructor_float4x4()
             TestUtils.AreEqual(expected, new float3x3(f4x4));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_explicit_cast_float4x4()
         {
             var f4x4 = new float4x4(new float4(1, 2, 3, 4), new float4(5, 6, 7, 8), new float4(9, 10, 11, 12), new float4(13, 14, 15, 16));
@@ -1161,7 +1161,7 @@ public static void float3x3_explicit_cast_float4x4()
             TestUtils.AreEqual(expected, (float3x3)f4x4);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_from_float4x4_without_new()
         {
             var f4x4 = new float4x4(new float4(1, 2, 3, 4), new float4(5, 6, 7, 8), new float4(9, 10, 11, 12), new float4(13, 14, 15, 16));
@@ -1170,7 +1170,7 @@ public static void float3x3_from_float4x4_without_new()
             TestUtils.AreEqual(expected, float3x3(f4x4));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_pseudoinverse_non_singular()
         {
             const float kTolerance = 1e-5f;
@@ -1191,7 +1191,7 @@ public static void float3x3_pseudoinverse_non_singular()
             TestUtils.AreEqual(expected, inverse(a), kTolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3x3_pseudoinverse_singular()
         {
             const float kTolerance = 1e-5f;
diff --git a/src/Tests/Tests/Shared/TestMinMaxAABB.cs b/src/Tests/Tests/Shared/TestMinMaxAABB.cs
index 7c5c5e8c..a08e52cd 100644
--- a/src/Tests/Tests/Shared/TestMinMaxAABB.cs
+++ b/src/Tests/Tests/Shared/TestMinMaxAABB.cs
@@ -9,7 +9,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestMinMaxAABB
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Encapsulate_float3_trivial()
         {
             var aabb = new MinMaxAABB();
@@ -18,7 +18,7 @@ public static void Encapsulate_float3_trivial()
             TestUtils.AreEqual(float3.zero, aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Encapsulate_float3_new_max()
         {
             var aabb = new MinMaxAABB();
@@ -27,7 +27,7 @@ public static void Encapsulate_float3_new_max()
             TestUtils.AreEqual(new float3(1.0f), aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Encapsulate_float3_new_min()
         {
             var aabb = new MinMaxAABB();
@@ -36,7 +36,7 @@ public static void Encapsulate_float3_new_min()
             TestUtils.AreEqual(new float3(-1.0f), aabb.Min);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Encapsulate_float3_new_minx_maxyz()
         {
             var aabb = new MinMaxAABB();
@@ -45,7 +45,7 @@ public static void Encapsulate_float3_new_minx_maxyz()
             TestUtils.AreEqual(new float3(0.0f, 1.0f, 1.0f), aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Encapsulate_float3_new_minxy_maxz()
         {
             var aabb = new MinMaxAABB();
@@ -54,7 +54,7 @@ public static void Encapsulate_float3_new_minxy_maxz()
             TestUtils.AreEqual(new float3(0.0f, 0.0f, 1.0f), aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Encapsulate_float3_new_minxz_maxy()
         {
             var aabb = new MinMaxAABB();
@@ -63,7 +63,7 @@ public static void Encapsulate_float3_new_minxz_maxy()
             TestUtils.AreEqual(new float3(0.0f, 1.0f, 0.0f), aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Encapsulate_float3_new_minz_maxxy()
         {
             var aabb = new MinMaxAABB();
@@ -72,7 +72,7 @@ public static void Encapsulate_float3_new_minz_maxxy()
             TestUtils.AreEqual(new float3(1.0f, 1.0f, 0.0f), aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Encapsulate_float3_new_miny_maxxz()
         {
             var aabb = new MinMaxAABB();
@@ -81,7 +81,7 @@ public static void Encapsulate_float3_new_miny_maxxz()
             TestUtils.AreEqual(new float3(1.0f, 0.0f, 1.0f), aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Encapsulate_MinMaxAABB_trivial()
         {
             var aabb = new MinMaxAABB();
@@ -90,7 +90,7 @@ public static void Encapsulate_MinMaxAABB_trivial()
             TestUtils.AreEqual(float3.zero, aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Encapsulate_MinMaxAABB_new_max()
         {
             var aabb = new MinMaxAABB();
@@ -100,7 +100,7 @@ public static void Encapsulate_MinMaxAABB_new_max()
             TestUtils.AreEqual(p, aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Encapsulate_MinMaxAABB_new_min()
         {
             var aabb = new MinMaxAABB();
@@ -110,7 +110,7 @@ public static void Encapsulate_MinMaxAABB_new_min()
             TestUtils.AreEqual(p, aabb.Min);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Encapsulate_MinMaxAABB_new_minx_maxyz()
         {
             var aabb = new MinMaxAABB();
@@ -119,7 +119,7 @@ public static void Encapsulate_MinMaxAABB_new_minx_maxyz()
             TestUtils.AreEqual(new float3(0.0f, 1.0f, 1.0f), aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Encapsulate_MinMaxAABB_new_minxy_maxz()
         {
             var aabb = new MinMaxAABB();
@@ -128,7 +128,7 @@ public static void Encapsulate_MinMaxAABB_new_minxy_maxz()
             TestUtils.AreEqual(new float3(0.0f, 0.0f, 1.0f), aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Encapsulate_MinMaxAABB_new_minxz_maxy()
         {
             var aabb = new MinMaxAABB();
@@ -137,7 +137,7 @@ public static void Encapsulate_MinMaxAABB_new_minxz_maxy()
             TestUtils.AreEqual(new float3(0.0f, 1.0f, 0.0f), aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Encapsulate_MinMaxAABB_new_minz_maxxy()
         {
             var aabb = new MinMaxAABB();
@@ -146,7 +146,7 @@ public static void Encapsulate_MinMaxAABB_new_minz_maxxy()
             TestUtils.AreEqual(new float3(1.0f, 1.0f, 0.0f), aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Encapsulate_MinMaxAABB_new_miny_maxxz()
         {
             var aabb = new MinMaxAABB();
@@ -155,14 +155,14 @@ public static void Encapsulate_MinMaxAABB_new_miny_maxxz()
             TestUtils.AreEqual(new float3(1.0f, 0.0f, 1.0f), aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Equals_trivial()
         {
             MinMaxAABB aabb = new MinMaxAABB();
             TestUtils.IsTrue(aabb.Equals(aabb));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Equals()
         {
             MinMaxAABB aabb1 = new MinMaxAABB { Min = new float3(-123.0f, 0.5182f, 20.0f), Max = new float3(1.0f, -1.0f, 0.99191f) };
@@ -171,7 +171,7 @@ public static void Equals()
             TestUtils.IsTrue(aabb2.Equals(aabb1));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Equals_diff_minx()
         {
             MinMaxAABB aabb1 = new MinMaxAABB();
@@ -180,7 +180,7 @@ public static void Equals_diff_minx()
             TestUtils.IsFalse(aabb2.Equals(aabb1));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Equals_diff_miny()
         {
             MinMaxAABB aabb1 = new MinMaxAABB();
@@ -189,7 +189,7 @@ public static void Equals_diff_miny()
             TestUtils.IsFalse(aabb2.Equals(aabb1));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Equals_diff_minz()
         {
             MinMaxAABB aabb1 = new MinMaxAABB();
@@ -198,7 +198,7 @@ public static void Equals_diff_minz()
             TestUtils.IsFalse(aabb2.Equals(aabb1));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Equals_diff_maxx()
         {
             MinMaxAABB aabb1 = new MinMaxAABB();
@@ -207,7 +207,7 @@ public static void Equals_diff_maxx()
             TestUtils.IsFalse(aabb2.Equals(aabb1));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Equals_diff_maxy()
         {
             MinMaxAABB aabb1 = new MinMaxAABB();
@@ -216,7 +216,7 @@ public static void Equals_diff_maxy()
             TestUtils.IsFalse(aabb2.Equals(aabb1));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Equals_diff_maxz()
         {
             MinMaxAABB aabb1 = new MinMaxAABB();
@@ -225,7 +225,7 @@ public static void Equals_diff_maxz()
             TestUtils.IsFalse(aabb2.Equals(aabb1));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void SurfaceArea()
         {
             var min = new float3(-47.989063262939453125f, 28.037994384765625f, -9.756519317626953125f);
@@ -235,7 +235,7 @@ public static void SurfaceArea()
             TestUtils.AreEqual(14400.470703125f, aabb.SurfaceArea, 1, true);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Extents()
         {
             var min = new float3(48.152984619140625f, -33.58978271484375f, -37.498805999755859375f);
@@ -246,7 +246,7 @@ public static void Extents()
             TestUtils.AreEqual(expected, aabb.Extents);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Center()
         {
             var min = new float3(47.902675628662109375f, -34.302494049072265625f, 22.7147884368896484375f);
@@ -257,7 +257,7 @@ public static void Center()
             TestUtils.AreEqual(expected, aabb.Center);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void HalfExtents()
         {
             var min = new float3(-14.3485383987426757813f, 28.68161773681640625f, -40.28060150146484375f);
@@ -268,7 +268,7 @@ public static void HalfExtents()
             TestUtils.AreEqual(expected, aabb.HalfExtents);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Constructor()
         {
             var min = new float3(38.95940399169921875f, -24.644245147705078125f, 27.7903194427490234375f);
@@ -279,7 +279,7 @@ public static void Constructor()
             TestUtils.AreEqual(max, aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ContainsPoint()
         {
             var aabb = new MinMaxAABB(new float3(-1), new float3(1));
@@ -301,7 +301,7 @@ public static void ContainsPoint()
             TestUtils.IsFalse(aabb.Contains(new float3(-1.0f, -1.0f, -1.0f - EPSILON)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ContainsAabb_Trivial()
         {
             var aabb1 = new MinMaxAABB();
@@ -311,7 +311,7 @@ public static void ContainsAabb_Trivial()
             TestUtils.IsTrue(aabb2.Contains(aabb1));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ContainsAabb()
         {
             var aabb1 = new MinMaxAABB(new float3(-1.0f), new float3(1.0f));
@@ -321,7 +321,7 @@ public static void ContainsAabb()
             TestUtils.IsFalse(aabb2.Contains(aabb1));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ContainsAabb_BarelyNotContained()
         {
             var aabb1 = new MinMaxAABB(new float3(-1.0f), new float3(1.0f));
@@ -340,7 +340,7 @@ public static void ContainsAabb_BarelyNotContained()
             TestUtils.IsFalse(aabb1.Contains(aabb7));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Overlap_Trivial()
         {
             var aabb = new MinMaxAABB();
@@ -348,7 +348,7 @@ public static void Overlap_Trivial()
             TestUtils.IsTrue(aabb.Overlaps(aabb));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Overlap_Corner()
         {
             var aabb = new MinMaxAABB(new float3(-1.0f), new float3(1.0f));
@@ -389,7 +389,7 @@ public static void Overlap_Corner()
             TestUtils.IsTrue(cornerAabb8.Overlaps(aabb));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void NoOverlap_Corner()
         {
             var aabb = new MinMaxAABB(new float3(-1.0f), new float3(1.0f));
@@ -430,7 +430,7 @@ public static void NoOverlap_Corner()
             TestUtils.IsFalse(cornerAabb8.Overlaps(aabb));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Expand_PositiveDistance()
         {
             var aabb = new MinMaxAABB(new float3(-0.5f), new float3(0.5f));
@@ -440,7 +440,7 @@ public static void Expand_PositiveDistance()
             TestUtils.AreEqual(new float3(1.5f), aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Expand_NegativeDistance()
         {
             var aabb = new MinMaxAABB(new float3(-0.5f), new float3(0.5f));
@@ -450,7 +450,7 @@ public static void Expand_NegativeDistance()
             TestUtils.AreEqual(new float3(-0.5f), aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void CreateFromCenterAndExtents()
         {
             var center = new float3(-29.2458133697509765625f, 1.21094369888305664063f, 34.281322479248046875f);
@@ -463,7 +463,7 @@ public static void CreateFromCenterAndExtents()
             TestUtils.AreEqual(expectedMax, aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void CreateFromCenterAndHalfExtents()
         {
             var center = new float3(-29.2458133697509765625f, 1.21094369888305664063f, 34.281322479248046875f);
@@ -476,14 +476,14 @@ public static void CreateFromCenterAndHalfExtents()
             TestUtils.AreEqual(expectedMax, aabb.Max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void IsValid_Trivial()
         {
             TestUtils.IsTrue(new MinMaxAABB().IsValid);
             TestUtils.IsFalse(new MinMaxAABB(new float3(1.0f), new float3(-1.0f)).IsValid);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void IsValid_OneComponentInvalid()
         {
             TestUtils.IsFalse(new MinMaxAABB(float3.zero, new float3(-1.0f, 0.0f, 0.0f)).IsValid);
@@ -494,7 +494,7 @@ public static void IsValid_OneComponentInvalid()
             TestUtils.IsFalse(new MinMaxAABB(new float3(0.0f, 0.0f, 1.0f), float3.zero).IsValid);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Transform_RigidTransform()
         {
             var t = new RigidTransform(quaternion.EulerXYZ(PI * 0.25f), new float3(1.0f, 1.0f, 1.0f));
@@ -507,7 +507,7 @@ public static void Transform_RigidTransform()
             TestUtils.AreEqual(expectedMax, aabb.Max, tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Transform_float4x4()
         {
             var t = new float4x4(float3x3.EulerXYZ(PI * 0.25f), new float3(1.0f, 1.0f, 1.0f));
@@ -520,7 +520,7 @@ public static void Transform_float4x4()
             TestUtils.AreEqual(expectedMax, aabb.Max, tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Transform_float3x3()
         {
             var t = float3x3.EulerXYZ(PI * 0.25f);
diff --git a/src/Tests/Tests/Shared/TestPlane.cs b/src/Tests/Tests/Shared/TestPlane.cs
index 91e60044..c79ecb0b 100644
--- a/src/Tests/Tests/Shared/TestPlane.cs
+++ b/src/Tests/Tests/Shared/TestPlane.cs
@@ -10,7 +10,7 @@ public class TestPlane
         // An arbitrary tolerance.
         const float Tolerance = 0.0000025f;
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Empty()
         {
             var p = new Plane();
@@ -20,7 +20,7 @@ public static void Empty()
             TestUtils.AreEqual(0.0f, p.Distance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void GetNormal()
         {
             var p = new Plane { NormalAndDistance = new float4(1.0f, 2.0f, 3.0f, 4.0f) };
@@ -28,7 +28,7 @@ public static void GetNormal()
             TestUtils.AreEqual(new float3(1.0f, 2.0f, 3.0f), p.Normal);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void GetDistance()
         {
             var p = new Plane { NormalAndDistance = new float4(1.0f, 2.0f, 3.0f, 4.0f) };
@@ -36,7 +36,7 @@ public static void GetDistance()
             TestUtils.AreEqual(4.0f, p.Distance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void SetNormal()
         {
             var p = new Plane { NormalAndDistance = new float4(1.0f, 2.0f, 3.0f, 4.0f) };
@@ -45,7 +45,7 @@ public static void SetNormal()
             TestUtils.AreEqual(new float3(-1.0f, -2.0f, -3.0f), p.Normal);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void SetDistance()
         {
             var p = new Plane { NormalAndDistance = new float4(1.0f, 2.0f, 3.0f, 4.0f) };
@@ -54,7 +54,7 @@ public static void SetDistance()
             TestUtils.AreEqual(-4.0f, p.Distance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ConstructWithNormalAndDistance()
         {
             var n = math.normalize(new float3(4.0f, -5.0f, 6.0f));
@@ -66,7 +66,7 @@ public static void ConstructWithNormalAndDistance()
             TestUtils.AreEqual(d, p.Distance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ConstructWithCoefficients_NonUnitLengthNormal()
         {
             var abcd = new float4(4.0f, -5.0f, 6.0f, 123.0f);
@@ -78,7 +78,7 @@ public static void ConstructWithCoefficients_NonUnitLengthNormal()
             TestUtils.AreEqual(expected.w, p.Distance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ConstructWithNormalAndPointInPlane_NegativeDistance()
         {
             var n = math.up();
@@ -90,7 +90,7 @@ public static void ConstructWithNormalAndPointInPlane_NegativeDistance()
             TestUtils.AreEqual(-1.0f, p.Distance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ConstructWithNormalAndPointInPlane_PositiveDistance()
         {
             var n = math.down();
@@ -102,7 +102,7 @@ public static void ConstructWithNormalAndPointInPlane_PositiveDistance()
             TestUtils.AreEqual(1.0f, p.Distance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ConstructWithNormalAndPointInPlane()
         {
             var normal = new float3(2.0f, 2.0f, 2.0f);
@@ -116,7 +116,7 @@ public static void ConstructWithNormalAndPointInPlane()
             TestUtils.AreEqual(expectedD, p.Distance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ConstructWithTwoVectorsAndOrigin_Trivial()
         {
             var v1 = new float3(1.0f, 0.0f, 0.0f);
@@ -126,7 +126,7 @@ public static void ConstructWithTwoVectorsAndOrigin_Trivial()
             TestUtils.AreEqual(new float4(0.0f, 0.0f, 1.0f, 0.0f), p);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ConstructWithTwoVectorsAndOrigin_NonZeroOrigin()
         {
             var v1 = new float3(5.0f, 0.0f, 0.0f);
@@ -136,7 +136,7 @@ public static void ConstructWithTwoVectorsAndOrigin_NonZeroOrigin()
             TestUtils.AreEqual(new float4(0.0f, 0.0f, -1.0f, 1.0f), p);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void SignedDistanceToPoint()
         {
             var vInPlane1 = new float3(2.0f, 1.0f, -0.18f);
@@ -152,7 +152,7 @@ public static void SignedDistanceToPoint()
             TestUtils.AreEqual(-1.0f, p.SignedDistanceToPoint(pointInPlane - n), Tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void SignedDistanceToPointTrivial()
         {
             var p = new Plane(math.up(), 0.0f);
@@ -174,7 +174,7 @@ public static void SignedDistanceToPointTrivial()
             TestUtils.AreEqual(-1.0f, p.SignedDistanceToPoint(math.down() + math.forward()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ProjectionTrivial()
         {
             var p = new Plane(math.up(), 0.0f);
@@ -183,7 +183,7 @@ public static void ProjectionTrivial()
             TestUtils.AreEqual(expected, p.Projection(math.up() + expected));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Projection()
         {
             var normal = new float3(1.0f);
@@ -195,7 +195,7 @@ public static void Projection()
             TestUtils.AreEqual(expected, p.Projection(expected), math.EPSILON);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void Flipped()
         {
             var normal = new float3(1.0f);
@@ -207,7 +207,7 @@ public static void Flipped()
             TestUtils.AreEqual(new float4(expectedN, expectedD), p.Flipped, Tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void ImplicitToFloat4()
         {
             var normal = new float3(1.1f, -20.0f, 15.182f);
@@ -220,7 +220,7 @@ public static void ImplicitToFloat4()
             TestUtils.AreEqual(new float4(expectedN, expectedD), p_as_float4, Tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void NormalizeFloat4()
         {
             var p = new float4(8.215876543024162e-01f, 2.786574280629829e-01f, 8.121669997361285e-01f, 9.352839276497152e-01f);
@@ -229,7 +229,7 @@ public static void NormalizeFloat4()
             TestUtils.AreEqual(expected, Plane.Normalize(p), Tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void NormalizePlane()
         {
             var p = new Plane { NormalAndDistance = new float4(8.215876543024162e-01f, 2.786574280629829e-01f, 8.121669997361285e-01f, 9.352839276497152e-01f) };
@@ -241,7 +241,7 @@ public static void NormalizePlane()
             TestUtils.AreEqual(expected.w, normalized.Distance, Tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void CreateFromUnitNormalAndDistance()
         {
             var n = new float3(9.108767140247756e-02f, 3.966831912609620e-01f, 9.134251375397404e-01f);
@@ -252,7 +252,7 @@ public static void CreateFromUnitNormalAndDistance()
             TestUtils.AreEqual(expected, p.NormalAndDistance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void CreateFromUnitNormalAndPointInPlane()
         {
             var n = new float3(4.724920516359185e-01f, 1.444614284194820e-01f, 8.694148358751899e-01f);
diff --git a/src/Tests/Tests/Shared/TestQuaternion.cs b/src/Tests/Tests/Shared/TestQuaternion.cs
index 301725ee..0279de90 100644
--- a/src/Tests/Tests/Shared/TestQuaternion.cs
+++ b/src/Tests/Tests/Shared/TestQuaternion.cs
@@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     class TestQuaternion
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_basic_constructors()
         {
             quaternion q = quaternion(1.0f, 2.0f, 3.0f, 4.0f);
@@ -23,7 +23,7 @@ public static void quaternion_basic_constructors()
             TestUtils.AreEqual(4.0f, q2.value.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_construct_from_matrix()
         {
             TestUtils.AreEqual(float3x3(quaternion(TestMatrix.test3x3_xyz)), TestMatrix.test3x3_xyz, 0.0001f);
@@ -45,7 +45,7 @@ public static void quaternion_construct_from_matrix()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_construct_from_matrix3x3_torture()
         {
             Random rnd = new Random(0x12345678);
@@ -58,7 +58,7 @@ public static void quaternion_construct_from_matrix3x3_torture()
             }
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_construct_from_matrix4x4_torture()
         {
             Random rnd = new Random(0x12345678);
@@ -71,7 +71,7 @@ public static void quaternion_construct_from_matrix4x4_torture()
             }
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_axis_angle()
         {
             quaternion q = quaternion.AxisAngle(normalize(float3(1.0f, 2.0f, 3.0f)), 10.0f);
@@ -80,7 +80,7 @@ public static void quaternion_axis_angle()
             TestUtils.AreEqual(r, q, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_axis_angle_consistency()
         {
             TestUtils.AreEqual(quaternion.RotateX(1.0f), quaternion.AxisAngle(float3(1, 0, 0), 1.0f), 0.001f);
@@ -88,7 +88,7 @@ public static void quaternion_axis_angle_consistency()
             TestUtils.AreEqual(quaternion.RotateZ(1.0f), quaternion.AxisAngle(float3(0, 0, 1), 1.0f), 0.001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void euler_to_quaternion()
         {
             float3 test_angles = TestMatrix.test_angles;
@@ -158,7 +158,7 @@ public static void euler_to_quaternion()
             TestUtils.AreEqual(TestMatrix.test3x3_zyx, m1_zyx, epsilon);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_rotateX()
         {
             float angle = 2.3f;
@@ -168,7 +168,7 @@ public static void quaternion_rotateX()
             TestUtils.AreEqual(r, q, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_rotateY()
         {
             float angle = 2.3f;
@@ -178,7 +178,7 @@ public static void quaternion_rotateY()
             TestUtils.AreEqual(r, q, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_rotateZ()
         {
             float angle = 2.3f;
@@ -193,7 +193,7 @@ public static void quaternion_rotateZ()
         static internal readonly quaternion test_q2 = new quaternion(-0.2316205f, -0.6022133f, -0.7411857f, -0.1852964f);
         static internal readonly quaternion test_q3 = new quaternion(0.3619499f, 0.8352691f, -0.1392115f, 0.3897922f);
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_conjugate()
         {
             quaternion q = quaternion(1.0f, -2.0f, 3.0f, -4.0f);
@@ -203,7 +203,7 @@ public static void quaternion_conjugate()
             TestUtils.AreEqual(r, cq);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_inverse()
         {
             quaternion q = quaternion(1.0f, -2.0f, 3.0f, -4.0f);
@@ -213,7 +213,7 @@ public static void quaternion_inverse()
             TestUtils.AreEqual(quaternion.identity, qiq, 0.00001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_dot()
         {
             float dot01 = dot(test_q0, test_q1);
@@ -223,7 +223,7 @@ public static void quaternion_dot()
             TestUtils.AreEqual(-0.5795583f, dot02, 0.00001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_nlerp()
         {
             quaternion r0 = nlerp(test_q0, test_q1, 0.3f);
@@ -235,7 +235,7 @@ public static void quaternion_nlerp()
             TestUtils.AreEqual(quaternion(-0.4054004f, 0.06570576f, -0.7457358f, -0.5246059f), r2, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_slerp()
         {
             quaternion r0 = slerp(test_q0, test_q1, 0.3f);
@@ -247,7 +247,7 @@ public static void quaternion_slerp()
             TestUtils.AreEqual(quaternion(0.2596942f, -0.4369303f, 0.7902023f, 0.34239f), r2, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_mul_vector()
         {
             float3x3 m = TestMatrix.test3x3_xyz;
@@ -261,7 +261,7 @@ public static void quaternion_mul_vector()
             TestUtils.AreEqual(mvector, qvector, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_log_exp_identity()
         {
             quaternion q = quaternion(1.2f, -2.6f, 3.1f, 6.0f);
@@ -270,7 +270,7 @@ public static void quaternion_log_exp_identity()
             TestUtils.AreEqual(q, exp_log_q, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_log_exp_rotation()
         {
             quaternion q = quaternion(TestMatrix.test3x3_xyz);
@@ -280,7 +280,7 @@ public static void quaternion_log_exp_rotation()
             TestUtils.AreEqual(q3, t, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_unitlog_unitexp_rotation()
         {
             quaternion q = quaternion(TestMatrix.test3x3_xyz);
@@ -290,7 +290,7 @@ public static void quaternion_unitlog_unitexp_rotation()
             TestUtils.AreEqual(q3, t, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_look_rotation()
         {
             // Exercise the 4 cases
@@ -319,7 +319,7 @@ public static void quaternion_look_rotation()
             TestUtils.AreEqual(float3x3.LookRotation(forward3, up3), float3x3(q3), 0.001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_look_rotation_safe()
         {
             float3 forward0 = float3(-3.2f, 2.3f, -1.3f) * 1e-10f;
@@ -381,7 +381,7 @@ public static void quaternion_angle()
             TestUtils.AreEqual(0f, angle);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_rotation_from_3x3_identity()
         {
             const float tolerance = 1e-5f;
@@ -389,7 +389,7 @@ public static void quaternion_rotation_from_3x3_identity()
             TestUtils.AreEqual(quaternion.identity, q, tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_rotation_from_3x3_with_uniform_scale()
         {
             const float tolerance = 1e-5f;
@@ -401,7 +401,7 @@ public static void quaternion_rotation_from_3x3_with_uniform_scale()
             TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_rotation_from_3x3_with_nonuniform_scale()
         {
             const float tolerance = 1e-5f;
@@ -413,7 +413,7 @@ public static void quaternion_rotation_from_3x3_with_nonuniform_scale()
             TestUtils.AreEqual(quaternion.identity, q, tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_rotation_from_3x3_with_negative_scale_x()
         {
             const float tolerance = 1e-5f;
@@ -425,7 +425,7 @@ public static void quaternion_rotation_from_3x3_with_negative_scale_x()
             TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_rotation_from_3x3_with_negative_scale_y()
         {
             const float tolerance = 1e-5f;
@@ -437,7 +437,7 @@ public static void quaternion_rotation_from_3x3_with_negative_scale_y()
             TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_rotation_from_3x3_with_negative_scale_z()
         {
             const float tolerance = 1e-5f;
@@ -449,7 +449,7 @@ public static void quaternion_rotation_from_3x3_with_negative_scale_z()
             TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_rotation_from_3x3_with_negative_nonuniform_scale()
         {
             const float tolerance = 1e-5f;
diff --git a/src/Tests/Tests/Shared/TestRigidTransform.cs b/src/Tests/Tests/Shared/TestRigidTransform.cs
index ac0d8060..eacec9ed 100644
--- a/src/Tests/Tests/Shared/TestRigidTransform.cs
+++ b/src/Tests/Tests/Shared/TestRigidTransform.cs
@@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     class TestRigidTransform
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rigid_transform_construct_from_matrix()
         {
             float4x4 m4x4 = TestMatrix.test4x4_zyx;
@@ -19,7 +19,7 @@ public static void rigid_transform_construct_from_matrix()
             TestUtils.AreEqual(m4x4, mq4x4, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rigid_transform_axisAngle()
         {
             RigidTransform q = RigidTransform.AxisAngle(normalize(float3(1.0f, 2.0f, 3.0f)), 10.0f);
@@ -28,7 +28,7 @@ public static void rigid_transform_axisAngle()
             TestUtils.AreEqual(r, q, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rigid_transform_euler()
         {
             float3 test_angles = TestMatrix.test_angles;
@@ -98,7 +98,7 @@ public static void rigid_transform_euler()
             TestUtils.AreEqual(TestMatrix.test3x3_zyx, m1_zyx, epsilon);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rigid_transform_rotateX()
         {
             float angle = 2.3f;
@@ -108,7 +108,7 @@ public static void rigid_transform_rotateX()
             TestUtils.AreEqual(r, q, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rigid_transform_rotateY()
         {
             float angle = 2.3f;
@@ -118,7 +118,7 @@ public static void rigid_transform_rotateY()
             TestUtils.AreEqual(r, q, 0.0001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rigid_transform_rotateZ()
         {
             float angle = 2.3f;
@@ -133,7 +133,7 @@ public static void rigid_transform_rotateZ()
         static internal readonly quaternion test_q2 = new quaternion(-0.2316205f, -0.6022133f, -0.7411857f, -0.1852964f);
         static internal readonly quaternion test_q3 = new quaternion(0.3619499f, 0.8352691f, -0.1392115f, 0.3897922f);
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rigid_transform_inverse()
         {
             RigidTransform q = RigidTransform(quaternion(1.0f, -2.0f, 3.0f, -4.0f), float3(1,2,3));
@@ -143,7 +143,7 @@ public static void rigid_transform_inverse()
             TestUtils.AreEqual(RigidTransform.identity, qiq, 0.00001f);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void rigid_transform_mul_vector()
         {
             float4x4 m = TestMatrix.test4x4_xyz;
diff --git a/src/Tests/Tests/Shared/TestSvd.cs b/src/Tests/Tests/Shared/TestSvd.cs
index f5ae195c..db889bd9 100644
--- a/src/Tests/Tests/Shared/TestSvd.cs
+++ b/src/Tests/Tests/Shared/TestSvd.cs
@@ -48,7 +48,7 @@ static void ValidatePenrose2(in float3x3 a, in float3x3 b)
         static void ValidateSingular(in float3x3 a) =>
             TestUtils.AreEqual(0.0f, math.determinant(a), k_SVDTolerance);
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void CanSVDInverseNonSingularFloat3x3()
         {
             var mat = math.float3x3(
@@ -71,7 +71,7 @@ public static void CanSVDInverseNonSingularFloat3x3()
             TestUtils.AreEqual(1f, testIdentity.c2.z, k_SVDTolerance);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void CanSVDInverseFloat3x3With_NullColumn()
         {
             var mat = math.float3x3(
@@ -89,7 +89,7 @@ public static void CanSVDInverseFloat3x3With_NullColumn()
             ValidatePenrose2(inv, mat);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void CanSVDInverseFloat3x3With_NullRow()
         {
             var mat = math.float3x3(
@@ -107,7 +107,7 @@ public static void CanSVDInverseFloat3x3With_NullRow()
             ValidatePenrose2(inv, mat);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void CanSVDInverseFloat3x3With_LinearDependentColumn()
         {
             var mat = math.float3x3(
@@ -125,7 +125,7 @@ public static void CanSVDInverseFloat3x3With_LinearDependentColumn()
             ValidatePenrose2(inv, mat);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void CanSVDInverseFloat3x3With_LinearDependentRow()
         {
             var mat = math.float3x3(
@@ -143,7 +143,7 @@ public static void CanSVDInverseFloat3x3With_LinearDependentRow()
             ValidatePenrose2(inv, mat);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void CanSVDInverseFloat3x3With_RotatedZeroScale()
         {
             var m102030 = math.float3x3(quaternion.Euler(math.radians(10f), math.radians(20f), math.radians(30f)));
@@ -160,7 +160,7 @@ public static void CanSVDInverseFloat3x3With_RotatedZeroScale()
         }
 
         // Case 928598: The errors appear, when GameObject has a child with ParticleSystem which is rotated along the y-axis to -180 and is moved
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void CanExtractSVDRotationFromFloat3x3With_X180_Y0_Z181()
         {
             var q = quaternion.Euler(math.radians(180f), math.radians(0f), math.radians(181f));
@@ -170,7 +170,7 @@ public static void CanExtractSVDRotationFromFloat3x3With_X180_Y0_Z181()
         }
 
         // Case 938548: Assertion failed on expression: 'CompareApproximately(det, 1.0F, .005f)' when scaling system to 0 on at least 2 axes
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void CanExtractSVDRotationFromFloat3x3With_ZeroScaleXY()
         {
             var q0 = quaternion.Euler(math.radians(10f), math.radians(20f), math.radians(30f));
diff --git a/src/Tests/Tests/Shared/TestUint2.gen.cs b/src/Tests/Tests/Shared/TestUint2.gen.cs
index 67c0813b..04620a33 100644
--- a/src/Tests/Tests/Shared/TestUint2.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint2.gen.cs
@@ -15,14 +15,14 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_zero()
         {
             TestUtils.AreEqual(0u, uint2.zero.x);
             TestUtils.AreEqual(0u, uint2.zero.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_constructor()
         {
             uint2 a = new uint2(1, 2);
@@ -30,7 +30,7 @@ public static void uint2_constructor()
             TestUtils.AreEqual(2, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_scalar_constructor()
         {
             uint2 a = new uint2(17u);
@@ -38,7 +38,7 @@ public static void uint2_scalar_constructor()
             TestUtils.AreEqual(17u, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_static_constructor()
         {
             uint2 a = uint2(1, 2);
@@ -46,7 +46,7 @@ public static void uint2_static_constructor()
             TestUtils.AreEqual(2, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_static_scalar_constructor()
         {
             uint2 a = uint2(17u);
@@ -54,7 +54,7 @@ public static void uint2_static_scalar_constructor()
             TestUtils.AreEqual(17u, a.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_equal_wide_wide()
         {
             uint2 a0 = uint2(2105871082, 35218899);
@@ -78,7 +78,7 @@ public static void uint2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_equal_wide_scalar()
         {
             uint2 a0 = uint2(437822262, 2020661134);
@@ -102,7 +102,7 @@ public static void uint2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -126,7 +126,7 @@ public static void uint2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_not_equal_wide_wide()
         {
             uint2 a0 = uint2(1977284100, 1293292704);
@@ -150,7 +150,7 @@ public static void uint2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_not_equal_wide_scalar()
         {
             uint2 a0 = uint2(1038269360, 1427812625);
@@ -174,7 +174,7 @@ public static void uint2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -198,7 +198,7 @@ public static void uint2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_less_wide_wide()
         {
             uint2 a0 = uint2(1486550609, 1779244308);
@@ -222,7 +222,7 @@ public static void uint2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_less_wide_scalar()
         {
             uint2 a0 = uint2(796797557, 670113454);
@@ -246,7 +246,7 @@ public static void uint2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -270,7 +270,7 @@ public static void uint2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_greater_wide_wide()
         {
             uint2 a0 = uint2(2087717754, 1725569452);
@@ -294,7 +294,7 @@ public static void uint2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_greater_wide_scalar()
         {
             uint2 a0 = uint2(1208626274, 239697208);
@@ -318,7 +318,7 @@ public static void uint2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -342,7 +342,7 @@ public static void uint2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_less_equal_wide_wide()
         {
             uint2 a0 = uint2(154092149, 1515170149);
@@ -366,7 +366,7 @@ public static void uint2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_less_equal_wide_scalar()
         {
             uint2 a0 = uint2(1479531977, 1427983411);
@@ -390,7 +390,7 @@ public static void uint2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -414,7 +414,7 @@ public static void uint2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_greater_equal_wide_wide()
         {
             uint2 a0 = uint2(8538378, 2131749726);
@@ -438,7 +438,7 @@ public static void uint2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_greater_equal_wide_scalar()
         {
             uint2 a0 = uint2(2049236663, 182691143);
@@ -462,7 +462,7 @@ public static void uint2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -486,7 +486,7 @@ public static void uint2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_add_wide_wide()
         {
             uint2 a0 = uint2(2135171378, 21433296);
@@ -510,7 +510,7 @@ public static void uint2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_add_wide_scalar()
         {
             uint2 a0 = uint2(665815972, 1783729250);
@@ -534,7 +534,7 @@ public static void uint2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -558,7 +558,7 @@ public static void uint2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_sub_wide_wide()
         {
             uint2 a0 = uint2(1410318491, 1097280168);
@@ -582,7 +582,7 @@ public static void uint2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_sub_wide_scalar()
         {
             uint2 a0 = uint2(1508669340, 1594795463);
@@ -606,7 +606,7 @@ public static void uint2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -630,7 +630,7 @@ public static void uint2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_mul_wide_wide()
         {
             uint2 a0 = uint2(61417577, 219585476);
@@ -654,7 +654,7 @@ public static void uint2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_mul_wide_scalar()
         {
             uint2 a0 = uint2(871746615, 492532311);
@@ -678,7 +678,7 @@ public static void uint2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -702,7 +702,7 @@ public static void uint2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_div_wide_wide()
         {
             uint2 a0 = uint2(333171510, 858154903);
@@ -726,7 +726,7 @@ public static void uint2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_div_wide_scalar()
         {
             uint2 a0 = uint2(1433072926, 1073958635);
@@ -750,7 +750,7 @@ public static void uint2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -774,7 +774,7 @@ public static void uint2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_mod_wide_wide()
         {
             uint2 a0 = uint2(258342924, 1454754891);
@@ -798,7 +798,7 @@ public static void uint2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_mod_wide_scalar()
         {
             uint2 a0 = uint2(560988938, 629524514);
@@ -822,7 +822,7 @@ public static void uint2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -846,7 +846,7 @@ public static void uint2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_plus()
         {
             uint2 a0 = uint2(195392567, 222719748);
@@ -866,7 +866,7 @@ public static void uint2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_neg()
         {
             uint2 a0 = uint2(1385088677, 94114564);
@@ -886,7 +886,7 @@ public static void uint2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_prefix_inc()
         {
             uint2 a0 = uint2(780471723, 954741756);
@@ -906,7 +906,7 @@ public static void uint2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_postfix_inc()
         {
             uint2 a0 = uint2(241865086, 2145821641);
@@ -926,7 +926,7 @@ public static void uint2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_prefix_dec()
         {
             uint2 a0 = uint2(1331961415, 1612382200);
@@ -946,7 +946,7 @@ public static void uint2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_postfix_dec()
         {
             uint2 a0 = uint2(1870005937, 1708534798);
@@ -966,7 +966,7 @@ public static void uint2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_bitwise_and_wide_wide()
         {
             uint2 a0 = uint2(1055241304, 859321394);
@@ -990,7 +990,7 @@ public static void uint2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_bitwise_and_wide_scalar()
         {
             uint2 a0 = uint2(1513158868, 284695609);
@@ -1014,7 +1014,7 @@ public static void uint2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1038,7 +1038,7 @@ public static void uint2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_bitwise_or_wide_wide()
         {
             uint2 a0 = uint2(1920951869, 1750772852);
@@ -1062,7 +1062,7 @@ public static void uint2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_bitwise_or_wide_scalar()
         {
             uint2 a0 = uint2(1295304853, 1307252624);
@@ -1086,7 +1086,7 @@ public static void uint2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1110,7 +1110,7 @@ public static void uint2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_bitwise_xor_wide_wide()
         {
             uint2 a0 = uint2(1843655608, 362425681);
@@ -1134,7 +1134,7 @@ public static void uint2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_bitwise_xor_wide_scalar()
         {
             uint2 a0 = uint2(169345668, 176087064);
@@ -1158,7 +1158,7 @@ public static void uint2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1182,7 +1182,7 @@ public static void uint2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_left_shift()
         {
             uint2 a0 = uint2(1129100049, 829482269);
@@ -1206,7 +1206,7 @@ public static void uint2_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_right_shift()
         {
             uint2 a0 = uint2(809126085, 908563670);
@@ -1230,7 +1230,7 @@ public static void uint2_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_operator_bitwise_not()
         {
             uint2 a0 = uint2(111796841, 603562399);
@@ -1250,7 +1250,7 @@ public static void uint2_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_shuffle_result_1()
         {
             uint2 a = uint2(0, 1);
@@ -1262,7 +1262,7 @@ public static void uint2_shuffle_result_1()
             TestUtils.AreEqual((3), shuffle(a, b, ShuffleComponent.RightY));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_shuffle_result_2()
         {
             uint2 a = uint2(0, 1);
@@ -1286,7 +1286,7 @@ public static void uint2_shuffle_result_2()
             TestUtils.AreEqual(uint2(3, 3), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_shuffle_result_3()
         {
             uint2 a = uint2(0, 1);
@@ -1310,7 +1310,7 @@ public static void uint2_shuffle_result_3()
             TestUtils.AreEqual(uint3(3, 1, 1), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_shuffle_result_4()
         {
             uint2 a = uint2(0, 1);
@@ -1334,7 +1334,7 @@ public static void uint2_shuffle_result_4()
             TestUtils.AreEqual(uint4(2, 0, 0, 0), shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX));
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void uint2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new uint2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestUint2x2.gen.cs b/src/Tests/Tests/Shared/TestUint2x2.gen.cs
index a5f371ec..dd8ed7a4 100644
--- a/src/Tests/Tests/Shared/TestUint2x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint2x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint2x2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_zero()
         {
             TestUtils.AreEqual(0u, uint2x2.zero.c0.x);
@@ -24,7 +24,7 @@ public static void uint2x2_zero()
             TestUtils.AreEqual(0u, uint2x2.zero.c1.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_identity()
         {
             TestUtils.AreEqual(1u, uint2x2.identity.c0.x);
@@ -33,7 +33,7 @@ public static void uint2x2_identity()
             TestUtils.AreEqual(1u, uint2x2.identity.c1.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_equal_wide_wide()
         {
             uint2x2 a0 = uint2x2(2105871082, 35218899, 1550755093, 764676020);
@@ -57,7 +57,7 @@ public static void uint2x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_equal_wide_scalar()
         {
             uint2x2 a0 = uint2x2(437822262, 2020661134, 541786900, 853113810);
@@ -81,7 +81,7 @@ public static void uint2x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -105,7 +105,7 @@ public static void uint2x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_not_equal_wide_wide()
         {
             uint2x2 a0 = uint2x2(1977284100, 1293292704, 1547283851, 422428953);
@@ -129,7 +129,7 @@ public static void uint2x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_not_equal_wide_scalar()
         {
             uint2x2 a0 = uint2x2(1038269360, 1427812625, 103361237, 1347017023);
@@ -153,7 +153,7 @@ public static void uint2x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -177,7 +177,7 @@ public static void uint2x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_less_wide_wide()
         {
             uint2x2 a0 = uint2x2(1486550609, 1779244308, 1602148045, 1614085440);
@@ -201,7 +201,7 @@ public static void uint2x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_less_wide_scalar()
         {
             uint2x2 a0 = uint2x2(796797557, 670113454, 933579492, 278884514);
@@ -225,7 +225,7 @@ public static void uint2x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -249,7 +249,7 @@ public static void uint2x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_greater_wide_wide()
         {
             uint2x2 a0 = uint2x2(2087717754, 1725569452, 1298066182, 1693943616);
@@ -273,7 +273,7 @@ public static void uint2x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_greater_wide_scalar()
         {
             uint2x2 a0 = uint2x2(1208626274, 239697208, 1979453345, 1253474001);
@@ -297,7 +297,7 @@ public static void uint2x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -321,7 +321,7 @@ public static void uint2x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_less_equal_wide_wide()
         {
             uint2x2 a0 = uint2x2(154092149, 1515170149, 1083970332, 785807178);
@@ -345,7 +345,7 @@ public static void uint2x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_less_equal_wide_scalar()
         {
             uint2x2 a0 = uint2x2(1479531977, 1427983411, 415250630, 1245345407);
@@ -369,7 +369,7 @@ public static void uint2x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -393,7 +393,7 @@ public static void uint2x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_greater_equal_wide_wide()
         {
             uint2x2 a0 = uint2x2(8538378, 2131749726, 265427108, 523609761);
@@ -417,7 +417,7 @@ public static void uint2x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_greater_equal_wide_scalar()
         {
             uint2x2 a0 = uint2x2(2049236663, 182691143, 634973382, 1197012109);
@@ -441,7 +441,7 @@ public static void uint2x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -465,7 +465,7 @@ public static void uint2x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_add_wide_wide()
         {
             uint2x2 a0 = uint2x2(2135171378, 21433296, 1954723494, 683604307);
@@ -489,7 +489,7 @@ public static void uint2x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_add_wide_scalar()
         {
             uint2x2 a0 = uint2x2(665815972, 1783729250, 1591678394, 1284528538);
@@ -513,7 +513,7 @@ public static void uint2x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -537,7 +537,7 @@ public static void uint2x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_sub_wide_wide()
         {
             uint2x2 a0 = uint2x2(1410318491, 1097280168, 1827039044, 28881338);
@@ -561,7 +561,7 @@ public static void uint2x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_sub_wide_scalar()
         {
             uint2x2 a0 = uint2x2(1508669340, 1594795463, 266707545, 643102647);
@@ -585,7 +585,7 @@ public static void uint2x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -609,7 +609,7 @@ public static void uint2x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_mul_wide_wide()
         {
             uint2x2 a0 = uint2x2(61417577, 219585476, 1362520891, 1511084277);
@@ -633,7 +633,7 @@ public static void uint2x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_mul_wide_scalar()
         {
             uint2x2 a0 = uint2x2(871746615, 492532311, 570557670, 2142306629);
@@ -657,7 +657,7 @@ public static void uint2x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -681,7 +681,7 @@ public static void uint2x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_div_wide_wide()
         {
             uint2x2 a0 = uint2x2(333171510, 858154903, 1181365836, 671357749);
@@ -705,7 +705,7 @@ public static void uint2x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_div_wide_scalar()
         {
             uint2x2 a0 = uint2x2(1433072926, 1073958635, 1195142312, 536596719);
@@ -729,7 +729,7 @@ public static void uint2x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -753,7 +753,7 @@ public static void uint2x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_mod_wide_wide()
         {
             uint2x2 a0 = uint2x2(258342924, 1454754891, 723352342, 1981431473);
@@ -777,7 +777,7 @@ public static void uint2x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_mod_wide_scalar()
         {
             uint2x2 a0 = uint2x2(560988938, 629524514, 767711194, 434281967);
@@ -801,7 +801,7 @@ public static void uint2x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -825,7 +825,7 @@ public static void uint2x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_plus()
         {
             uint2x2 a0 = uint2x2(195392567, 222719748, 1002351013, 1570765263);
@@ -845,7 +845,7 @@ public static void uint2x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_neg()
         {
             uint2x2 a0 = uint2x2(1385088677, 94114564, 1350664872, 1458616659);
@@ -865,7 +865,7 @@ public static void uint2x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_prefix_inc()
         {
             uint2x2 a0 = uint2x2(780471723, 954741756, 272723451, 2142862245);
@@ -885,7 +885,7 @@ public static void uint2x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_postfix_inc()
         {
             uint2x2 a0 = uint2x2(241865086, 2145821641, 1596166022, 803592338);
@@ -905,7 +905,7 @@ public static void uint2x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_prefix_dec()
         {
             uint2x2 a0 = uint2x2(1331961415, 1612382200, 1401591249, 2042075388);
@@ -925,7 +925,7 @@ public static void uint2x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_postfix_dec()
         {
             uint2x2 a0 = uint2x2(1870005937, 1708534798, 704493460, 462940703);
@@ -945,7 +945,7 @@ public static void uint2x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_bitwise_and_wide_wide()
         {
             uint2x2 a0 = uint2x2(1055241304, 859321394, 1088358961, 2090949513);
@@ -969,7 +969,7 @@ public static void uint2x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_bitwise_and_wide_scalar()
         {
             uint2x2 a0 = uint2x2(1513158868, 284695609, 734595037, 1566510707);
@@ -993,7 +993,7 @@ public static void uint2x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1017,7 +1017,7 @@ public static void uint2x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_bitwise_or_wide_wide()
         {
             uint2x2 a0 = uint2x2(1920951869, 1750772852, 1420019191, 732977093);
@@ -1041,7 +1041,7 @@ public static void uint2x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_bitwise_or_wide_scalar()
         {
             uint2x2 a0 = uint2x2(1295304853, 1307252624, 350194630, 1128063578);
@@ -1065,7 +1065,7 @@ public static void uint2x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1089,7 +1089,7 @@ public static void uint2x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_bitwise_xor_wide_wide()
         {
             uint2x2 a0 = uint2x2(1843655608, 362425681, 640805534, 1342040268);
@@ -1113,7 +1113,7 @@ public static void uint2x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_bitwise_xor_wide_scalar()
         {
             uint2x2 a0 = uint2x2(169345668, 176087064, 2084362901, 1663924004);
@@ -1137,7 +1137,7 @@ public static void uint2x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1161,7 +1161,7 @@ public static void uint2x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_left_shift()
         {
             uint2x2 a0 = uint2x2(1129100049, 829482269, 1571297368, 443753193);
@@ -1185,7 +1185,7 @@ public static void uint2x2_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_right_shift()
         {
             uint2x2 a0 = uint2x2(809126085, 908563670, 763568837, 1986717290);
@@ -1209,7 +1209,7 @@ public static void uint2x2_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x2_operator_bitwise_not()
         {
             uint2x2 a0 = uint2x2(111796841, 603562399, 745091931, 853183268);
@@ -1229,7 +1229,7 @@ public static void uint2x2_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void uint2x2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new uint2x2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestUint2x3.gen.cs b/src/Tests/Tests/Shared/TestUint2x3.gen.cs
index d8aa9b0a..0dcca69a 100644
--- a/src/Tests/Tests/Shared/TestUint2x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint2x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint2x3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_zero()
         {
             TestUtils.AreEqual(0u, uint2x3.zero.c0.x);
@@ -26,7 +26,7 @@ public static void uint2x3_zero()
             TestUtils.AreEqual(0u, uint2x3.zero.c2.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_equal_wide_wide()
         {
             uint2x3 a0 = uint2x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098);
@@ -50,7 +50,7 @@ public static void uint2x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_equal_wide_scalar()
         {
             uint2x3 a0 = uint2x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405);
@@ -74,7 +74,7 @@ public static void uint2x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -98,7 +98,7 @@ public static void uint2x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_not_equal_wide_wide()
         {
             uint2x3 a0 = uint2x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892);
@@ -122,7 +122,7 @@ public static void uint2x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_not_equal_wide_scalar()
         {
             uint2x3 a0 = uint2x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802);
@@ -146,7 +146,7 @@ public static void uint2x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -170,7 +170,7 @@ public static void uint2x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_less_wide_wide()
         {
             uint2x3 a0 = uint2x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342);
@@ -194,7 +194,7 @@ public static void uint2x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_less_wide_scalar()
         {
             uint2x3 a0 = uint2x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673);
@@ -218,7 +218,7 @@ public static void uint2x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -242,7 +242,7 @@ public static void uint2x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_greater_wide_wide()
         {
             uint2x3 a0 = uint2x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491);
@@ -266,7 +266,7 @@ public static void uint2x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_greater_wide_scalar()
         {
             uint2x3 a0 = uint2x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635);
@@ -290,7 +290,7 @@ public static void uint2x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -314,7 +314,7 @@ public static void uint2x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_less_equal_wide_wide()
         {
             uint2x3 a0 = uint2x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627);
@@ -338,7 +338,7 @@ public static void uint2x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_less_equal_wide_scalar()
         {
             uint2x3 a0 = uint2x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632);
@@ -362,7 +362,7 @@ public static void uint2x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -386,7 +386,7 @@ public static void uint2x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_greater_equal_wide_wide()
         {
             uint2x3 a0 = uint2x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564);
@@ -410,7 +410,7 @@ public static void uint2x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_greater_equal_wide_scalar()
         {
             uint2x3 a0 = uint2x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469);
@@ -434,7 +434,7 @@ public static void uint2x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -458,7 +458,7 @@ public static void uint2x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_add_wide_wide()
         {
             uint2x3 a0 = uint2x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995);
@@ -482,7 +482,7 @@ public static void uint2x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_add_wide_scalar()
         {
             uint2x3 a0 = uint2x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732);
@@ -506,7 +506,7 @@ public static void uint2x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -530,7 +530,7 @@ public static void uint2x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_sub_wide_wide()
         {
             uint2x3 a0 = uint2x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868);
@@ -554,7 +554,7 @@ public static void uint2x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_sub_wide_scalar()
         {
             uint2x3 a0 = uint2x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328);
@@ -578,7 +578,7 @@ public static void uint2x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -602,7 +602,7 @@ public static void uint2x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_mul_wide_wide()
         {
             uint2x3 a0 = uint2x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871);
@@ -626,7 +626,7 @@ public static void uint2x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_mul_wide_scalar()
         {
             uint2x3 a0 = uint2x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563);
@@ -650,7 +650,7 @@ public static void uint2x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -674,7 +674,7 @@ public static void uint2x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_div_wide_wide()
         {
             uint2x3 a0 = uint2x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420);
@@ -698,7 +698,7 @@ public static void uint2x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_div_wide_scalar()
         {
             uint2x3 a0 = uint2x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346);
@@ -722,7 +722,7 @@ public static void uint2x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -746,7 +746,7 @@ public static void uint2x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_mod_wide_wide()
         {
             uint2x3 a0 = uint2x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627);
@@ -770,7 +770,7 @@ public static void uint2x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_mod_wide_scalar()
         {
             uint2x3 a0 = uint2x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846);
@@ -794,7 +794,7 @@ public static void uint2x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -818,7 +818,7 @@ public static void uint2x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_plus()
         {
             uint2x3 a0 = uint2x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277);
@@ -838,7 +838,7 @@ public static void uint2x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_neg()
         {
             uint2x3 a0 = uint2x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493);
@@ -858,7 +858,7 @@ public static void uint2x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_prefix_inc()
         {
             uint2x3 a0 = uint2x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550);
@@ -878,7 +878,7 @@ public static void uint2x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_postfix_inc()
         {
             uint2x3 a0 = uint2x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229);
@@ -898,7 +898,7 @@ public static void uint2x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_prefix_dec()
         {
             uint2x3 a0 = uint2x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159);
@@ -918,7 +918,7 @@ public static void uint2x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_postfix_dec()
         {
             uint2x3 a0 = uint2x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869);
@@ -938,7 +938,7 @@ public static void uint2x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_bitwise_and_wide_wide()
         {
             uint2x3 a0 = uint2x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515);
@@ -962,7 +962,7 @@ public static void uint2x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_bitwise_and_wide_scalar()
         {
             uint2x3 a0 = uint2x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838);
@@ -986,7 +986,7 @@ public static void uint2x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1010,7 +1010,7 @@ public static void uint2x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_bitwise_or_wide_wide()
         {
             uint2x3 a0 = uint2x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930);
@@ -1034,7 +1034,7 @@ public static void uint2x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_bitwise_or_wide_scalar()
         {
             uint2x3 a0 = uint2x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467);
@@ -1058,7 +1058,7 @@ public static void uint2x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1082,7 +1082,7 @@ public static void uint2x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_bitwise_xor_wide_wide()
         {
             uint2x3 a0 = uint2x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850);
@@ -1106,7 +1106,7 @@ public static void uint2x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_bitwise_xor_wide_scalar()
         {
             uint2x3 a0 = uint2x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661);
@@ -1130,7 +1130,7 @@ public static void uint2x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1154,7 +1154,7 @@ public static void uint2x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_left_shift()
         {
             uint2x3 a0 = uint2x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593);
@@ -1178,7 +1178,7 @@ public static void uint2x3_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_right_shift()
         {
             uint2x3 a0 = uint2x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842);
@@ -1202,7 +1202,7 @@ public static void uint2x3_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x3_operator_bitwise_not()
         {
             uint2x3 a0 = uint2x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399);
@@ -1222,7 +1222,7 @@ public static void uint2x3_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void uint2x3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new uint2x3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestUint2x4.gen.cs b/src/Tests/Tests/Shared/TestUint2x4.gen.cs
index 7783684e..645d9554 100644
--- a/src/Tests/Tests/Shared/TestUint2x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint2x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint2x4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_zero()
         {
             TestUtils.AreEqual(0u, uint2x4.zero.c0.x);
@@ -28,7 +28,7 @@ public static void uint2x4_zero()
             TestUtils.AreEqual(0u, uint2x4.zero.c3.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_equal_wide_wide()
         {
             uint2x4 a0 = uint2x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316);
@@ -52,7 +52,7 @@ public static void uint2x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_equal_wide_scalar()
         {
             uint2x4 a0 = uint2x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849);
@@ -76,7 +76,7 @@ public static void uint2x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -100,7 +100,7 @@ public static void uint2x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_not_equal_wide_wide()
         {
             uint2x4 a0 = uint2x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074);
@@ -124,7 +124,7 @@ public static void uint2x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_not_equal_wide_scalar()
         {
             uint2x4 a0 = uint2x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717);
@@ -148,7 +148,7 @@ public static void uint2x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -172,7 +172,7 @@ public static void uint2x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_less_wide_wide()
         {
             uint2x4 a0 = uint2x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431);
@@ -196,7 +196,7 @@ public static void uint2x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_less_wide_scalar()
         {
             uint2x4 a0 = uint2x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600);
@@ -220,7 +220,7 @@ public static void uint2x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -244,7 +244,7 @@ public static void uint2x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_greater_wide_wide()
         {
             uint2x4 a0 = uint2x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508);
@@ -268,7 +268,7 @@ public static void uint2x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_greater_wide_scalar()
         {
             uint2x4 a0 = uint2x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098);
@@ -292,7 +292,7 @@ public static void uint2x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -316,7 +316,7 @@ public static void uint2x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_less_equal_wide_wide()
         {
             uint2x4 a0 = uint2x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725);
@@ -340,7 +340,7 @@ public static void uint2x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_less_equal_wide_scalar()
         {
             uint2x4 a0 = uint2x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307);
@@ -364,7 +364,7 @@ public static void uint2x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -388,7 +388,7 @@ public static void uint2x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_greater_equal_wide_wide()
         {
             uint2x4 a0 = uint2x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970);
@@ -412,7 +412,7 @@ public static void uint2x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_greater_equal_wide_scalar()
         {
             uint2x4 a0 = uint2x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187);
@@ -436,7 +436,7 @@ public static void uint2x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -460,7 +460,7 @@ public static void uint2x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_add_wide_wide()
         {
             uint2x4 a0 = uint2x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062);
@@ -484,7 +484,7 @@ public static void uint2x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_add_wide_scalar()
         {
             uint2x4 a0 = uint2x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017);
@@ -508,7 +508,7 @@ public static void uint2x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -532,7 +532,7 @@ public static void uint2x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_sub_wide_wide()
         {
             uint2x4 a0 = uint2x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215);
@@ -556,7 +556,7 @@ public static void uint2x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_sub_wide_scalar()
         {
             uint2x4 a0 = uint2x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511);
@@ -580,7 +580,7 @@ public static void uint2x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -604,7 +604,7 @@ public static void uint2x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_mul_wide_wide()
         {
             uint2x4 a0 = uint2x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644);
@@ -628,7 +628,7 @@ public static void uint2x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_mul_wide_scalar()
         {
             uint2x4 a0 = uint2x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514);
@@ -652,7 +652,7 @@ public static void uint2x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -676,7 +676,7 @@ public static void uint2x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_div_wide_wide()
         {
             uint2x4 a0 = uint2x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814);
@@ -700,7 +700,7 @@ public static void uint2x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_div_wide_scalar()
         {
             uint2x4 a0 = uint2x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670);
@@ -724,7 +724,7 @@ public static void uint2x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -748,7 +748,7 @@ public static void uint2x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_mod_wide_wide()
         {
             uint2x4 a0 = uint2x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004);
@@ -772,7 +772,7 @@ public static void uint2x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_mod_wide_scalar()
         {
             uint2x4 a0 = uint2x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916);
@@ -796,7 +796,7 @@ public static void uint2x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -820,7 +820,7 @@ public static void uint2x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_plus()
         {
             uint2x4 a0 = uint2x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785);
@@ -840,7 +840,7 @@ public static void uint2x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_neg()
         {
             uint2x4 a0 = uint2x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961);
@@ -860,7 +860,7 @@ public static void uint2x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_prefix_inc()
         {
             uint2x4 a0 = uint2x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162);
@@ -880,7 +880,7 @@ public static void uint2x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_postfix_inc()
         {
             uint2x4 a0 = uint2x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244);
@@ -900,7 +900,7 @@ public static void uint2x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_prefix_dec()
         {
             uint2x4 a0 = uint2x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664);
@@ -920,7 +920,7 @@ public static void uint2x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_postfix_dec()
         {
             uint2x4 a0 = uint2x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351);
@@ -940,7 +940,7 @@ public static void uint2x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_bitwise_and_wide_wide()
         {
             uint2x4 a0 = uint2x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753);
@@ -964,7 +964,7 @@ public static void uint2x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_bitwise_and_wide_scalar()
         {
             uint2x4 a0 = uint2x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908);
@@ -988,7 +988,7 @@ public static void uint2x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1012,7 +1012,7 @@ public static void uint2x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_bitwise_or_wide_wide()
         {
             uint2x4 a0 = uint2x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323);
@@ -1036,7 +1036,7 @@ public static void uint2x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_bitwise_or_wide_scalar()
         {
             uint2x4 a0 = uint2x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350);
@@ -1060,7 +1060,7 @@ public static void uint2x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1084,7 +1084,7 @@ public static void uint2x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_bitwise_xor_wide_wide()
         {
             uint2x4 a0 = uint2x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658);
@@ -1108,7 +1108,7 @@ public static void uint2x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_bitwise_xor_wide_scalar()
         {
             uint2x4 a0 = uint2x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783);
@@ -1132,7 +1132,7 @@ public static void uint2x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1156,7 +1156,7 @@ public static void uint2x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_left_shift()
         {
             uint2x4 a0 = uint2x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862);
@@ -1180,7 +1180,7 @@ public static void uint2x4_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_right_shift()
         {
             uint2x4 a0 = uint2x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632);
@@ -1204,7 +1204,7 @@ public static void uint2x4_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2x4_operator_bitwise_not()
         {
             uint2x4 a0 = uint2x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135);
@@ -1224,7 +1224,7 @@ public static void uint2x4_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void uint2x4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new uint2x4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestUint3.gen.cs b/src/Tests/Tests/Shared/TestUint3.gen.cs
index 6fca57ce..67055e17 100644
--- a/src/Tests/Tests/Shared/TestUint3.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_zero()
         {
             TestUtils.AreEqual(0u, uint3.zero.x);
@@ -23,7 +23,7 @@ public static void uint3_zero()
             TestUtils.AreEqual(0u, uint3.zero.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_constructor()
         {
             uint3 a = new uint3(1, 2, 3);
@@ -32,7 +32,7 @@ public static void uint3_constructor()
             TestUtils.AreEqual(3, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_scalar_constructor()
         {
             uint3 a = new uint3(17u);
@@ -41,7 +41,7 @@ public static void uint3_scalar_constructor()
             TestUtils.AreEqual(17u, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_static_constructor()
         {
             uint3 a = uint3(1, 2, 3);
@@ -50,7 +50,7 @@ public static void uint3_static_constructor()
             TestUtils.AreEqual(3, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_static_scalar_constructor()
         {
             uint3 a = uint3(17u);
@@ -59,7 +59,7 @@ public static void uint3_static_scalar_constructor()
             TestUtils.AreEqual(17u, a.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_equal_wide_wide()
         {
             uint3 a0 = uint3(2105871082, 35218899, 1550755093);
@@ -83,7 +83,7 @@ public static void uint3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_equal_wide_scalar()
         {
             uint3 a0 = uint3(437822262, 2020661134, 541786900);
@@ -107,7 +107,7 @@ public static void uint3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -131,7 +131,7 @@ public static void uint3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_not_equal_wide_wide()
         {
             uint3 a0 = uint3(1977284100, 1293292704, 1547283851);
@@ -155,7 +155,7 @@ public static void uint3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_not_equal_wide_scalar()
         {
             uint3 a0 = uint3(1038269360, 1427812625, 103361237);
@@ -179,7 +179,7 @@ public static void uint3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -203,7 +203,7 @@ public static void uint3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_less_wide_wide()
         {
             uint3 a0 = uint3(1486550609, 1779244308, 1602148045);
@@ -227,7 +227,7 @@ public static void uint3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_less_wide_scalar()
         {
             uint3 a0 = uint3(796797557, 670113454, 933579492);
@@ -251,7 +251,7 @@ public static void uint3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -275,7 +275,7 @@ public static void uint3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_greater_wide_wide()
         {
             uint3 a0 = uint3(2087717754, 1725569452, 1298066182);
@@ -299,7 +299,7 @@ public static void uint3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_greater_wide_scalar()
         {
             uint3 a0 = uint3(1208626274, 239697208, 1979453345);
@@ -323,7 +323,7 @@ public static void uint3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -347,7 +347,7 @@ public static void uint3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_less_equal_wide_wide()
         {
             uint3 a0 = uint3(154092149, 1515170149, 1083970332);
@@ -371,7 +371,7 @@ public static void uint3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_less_equal_wide_scalar()
         {
             uint3 a0 = uint3(1479531977, 1427983411, 415250630);
@@ -395,7 +395,7 @@ public static void uint3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -419,7 +419,7 @@ public static void uint3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_greater_equal_wide_wide()
         {
             uint3 a0 = uint3(8538378, 2131749726, 265427108);
@@ -443,7 +443,7 @@ public static void uint3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_greater_equal_wide_scalar()
         {
             uint3 a0 = uint3(2049236663, 182691143, 634973382);
@@ -467,7 +467,7 @@ public static void uint3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -491,7 +491,7 @@ public static void uint3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_add_wide_wide()
         {
             uint3 a0 = uint3(2135171378, 21433296, 1954723494);
@@ -515,7 +515,7 @@ public static void uint3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_add_wide_scalar()
         {
             uint3 a0 = uint3(665815972, 1783729250, 1591678394);
@@ -539,7 +539,7 @@ public static void uint3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -563,7 +563,7 @@ public static void uint3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_sub_wide_wide()
         {
             uint3 a0 = uint3(1410318491, 1097280168, 1827039044);
@@ -587,7 +587,7 @@ public static void uint3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_sub_wide_scalar()
         {
             uint3 a0 = uint3(1508669340, 1594795463, 266707545);
@@ -611,7 +611,7 @@ public static void uint3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -635,7 +635,7 @@ public static void uint3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_mul_wide_wide()
         {
             uint3 a0 = uint3(61417577, 219585476, 1362520891);
@@ -659,7 +659,7 @@ public static void uint3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_mul_wide_scalar()
         {
             uint3 a0 = uint3(871746615, 492532311, 570557670);
@@ -683,7 +683,7 @@ public static void uint3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -707,7 +707,7 @@ public static void uint3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_div_wide_wide()
         {
             uint3 a0 = uint3(333171510, 858154903, 1181365836);
@@ -731,7 +731,7 @@ public static void uint3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_div_wide_scalar()
         {
             uint3 a0 = uint3(1433072926, 1073958635, 1195142312);
@@ -755,7 +755,7 @@ public static void uint3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -779,7 +779,7 @@ public static void uint3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_mod_wide_wide()
         {
             uint3 a0 = uint3(258342924, 1454754891, 723352342);
@@ -803,7 +803,7 @@ public static void uint3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_mod_wide_scalar()
         {
             uint3 a0 = uint3(560988938, 629524514, 767711194);
@@ -827,7 +827,7 @@ public static void uint3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -851,7 +851,7 @@ public static void uint3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_plus()
         {
             uint3 a0 = uint3(195392567, 222719748, 1002351013);
@@ -871,7 +871,7 @@ public static void uint3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_neg()
         {
             uint3 a0 = uint3(1385088677, 94114564, 1350664872);
@@ -891,7 +891,7 @@ public static void uint3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_prefix_inc()
         {
             uint3 a0 = uint3(780471723, 954741756, 272723451);
@@ -911,7 +911,7 @@ public static void uint3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_postfix_inc()
         {
             uint3 a0 = uint3(241865086, 2145821641, 1596166022);
@@ -931,7 +931,7 @@ public static void uint3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_prefix_dec()
         {
             uint3 a0 = uint3(1331961415, 1612382200, 1401591249);
@@ -951,7 +951,7 @@ public static void uint3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_postfix_dec()
         {
             uint3 a0 = uint3(1870005937, 1708534798, 704493460);
@@ -971,7 +971,7 @@ public static void uint3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_bitwise_and_wide_wide()
         {
             uint3 a0 = uint3(1055241304, 859321394, 1088358961);
@@ -995,7 +995,7 @@ public static void uint3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_bitwise_and_wide_scalar()
         {
             uint3 a0 = uint3(1513158868, 284695609, 734595037);
@@ -1019,7 +1019,7 @@ public static void uint3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1043,7 +1043,7 @@ public static void uint3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_bitwise_or_wide_wide()
         {
             uint3 a0 = uint3(1920951869, 1750772852, 1420019191);
@@ -1067,7 +1067,7 @@ public static void uint3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_bitwise_or_wide_scalar()
         {
             uint3 a0 = uint3(1295304853, 1307252624, 350194630);
@@ -1091,7 +1091,7 @@ public static void uint3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1115,7 +1115,7 @@ public static void uint3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_bitwise_xor_wide_wide()
         {
             uint3 a0 = uint3(1843655608, 362425681, 640805534);
@@ -1139,7 +1139,7 @@ public static void uint3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_bitwise_xor_wide_scalar()
         {
             uint3 a0 = uint3(169345668, 176087064, 2084362901);
@@ -1163,7 +1163,7 @@ public static void uint3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1187,7 +1187,7 @@ public static void uint3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_left_shift()
         {
             uint3 a0 = uint3(1129100049, 829482269, 1571297368);
@@ -1211,7 +1211,7 @@ public static void uint3_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_right_shift()
         {
             uint3 a0 = uint3(809126085, 908563670, 763568837);
@@ -1235,7 +1235,7 @@ public static void uint3_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_operator_bitwise_not()
         {
             uint3 a0 = uint3(111796841, 603562399, 745091931);
@@ -1255,7 +1255,7 @@ public static void uint3_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_shuffle_result_1()
         {
             uint3 a = uint3(0, 1, 2);
@@ -1269,7 +1269,7 @@ public static void uint3_shuffle_result_1()
             TestUtils.AreEqual((5), shuffle(a, b, ShuffleComponent.RightZ));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_shuffle_result_2()
         {
             uint3 a = uint3(0, 1, 2);
@@ -1293,7 +1293,7 @@ public static void uint3_shuffle_result_2()
             TestUtils.AreEqual(uint2(1, 2), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_shuffle_result_3()
         {
             uint3 a = uint3(0, 1, 2);
@@ -1317,7 +1317,7 @@ public static void uint3_shuffle_result_3()
             TestUtils.AreEqual(uint3(4, 0, 5), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_shuffle_result_4()
         {
             uint3 a = uint3(0, 1, 2);
@@ -1341,7 +1341,7 @@ public static void uint3_shuffle_result_4()
             TestUtils.AreEqual(uint4(2, 5, 0, 4), shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightY));
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void uint3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new uint3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestUint3x2.gen.cs b/src/Tests/Tests/Shared/TestUint3x2.gen.cs
index 106b90dc..71742df7 100644
--- a/src/Tests/Tests/Shared/TestUint3x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint3x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint3x2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_zero()
         {
             TestUtils.AreEqual(0u, uint3x2.zero.c0.x);
@@ -26,7 +26,7 @@ public static void uint3x2_zero()
             TestUtils.AreEqual(0u, uint3x2.zero.c1.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_equal_wide_wide()
         {
             uint3x2 a0 = uint3x2(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098);
@@ -50,7 +50,7 @@ public static void uint3x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_equal_wide_scalar()
         {
             uint3x2 a0 = uint3x2(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405);
@@ -74,7 +74,7 @@ public static void uint3x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -98,7 +98,7 @@ public static void uint3x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_not_equal_wide_wide()
         {
             uint3x2 a0 = uint3x2(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892);
@@ -122,7 +122,7 @@ public static void uint3x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_not_equal_wide_scalar()
         {
             uint3x2 a0 = uint3x2(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802);
@@ -146,7 +146,7 @@ public static void uint3x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -170,7 +170,7 @@ public static void uint3x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_less_wide_wide()
         {
             uint3x2 a0 = uint3x2(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342);
@@ -194,7 +194,7 @@ public static void uint3x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_less_wide_scalar()
         {
             uint3x2 a0 = uint3x2(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673);
@@ -218,7 +218,7 @@ public static void uint3x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -242,7 +242,7 @@ public static void uint3x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_greater_wide_wide()
         {
             uint3x2 a0 = uint3x2(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491);
@@ -266,7 +266,7 @@ public static void uint3x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_greater_wide_scalar()
         {
             uint3x2 a0 = uint3x2(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635);
@@ -290,7 +290,7 @@ public static void uint3x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -314,7 +314,7 @@ public static void uint3x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_less_equal_wide_wide()
         {
             uint3x2 a0 = uint3x2(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627);
@@ -338,7 +338,7 @@ public static void uint3x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_less_equal_wide_scalar()
         {
             uint3x2 a0 = uint3x2(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632);
@@ -362,7 +362,7 @@ public static void uint3x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -386,7 +386,7 @@ public static void uint3x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_greater_equal_wide_wide()
         {
             uint3x2 a0 = uint3x2(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564);
@@ -410,7 +410,7 @@ public static void uint3x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_greater_equal_wide_scalar()
         {
             uint3x2 a0 = uint3x2(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469);
@@ -434,7 +434,7 @@ public static void uint3x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -458,7 +458,7 @@ public static void uint3x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_add_wide_wide()
         {
             uint3x2 a0 = uint3x2(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995);
@@ -482,7 +482,7 @@ public static void uint3x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_add_wide_scalar()
         {
             uint3x2 a0 = uint3x2(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732);
@@ -506,7 +506,7 @@ public static void uint3x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -530,7 +530,7 @@ public static void uint3x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_sub_wide_wide()
         {
             uint3x2 a0 = uint3x2(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868);
@@ -554,7 +554,7 @@ public static void uint3x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_sub_wide_scalar()
         {
             uint3x2 a0 = uint3x2(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328);
@@ -578,7 +578,7 @@ public static void uint3x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -602,7 +602,7 @@ public static void uint3x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_mul_wide_wide()
         {
             uint3x2 a0 = uint3x2(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871);
@@ -626,7 +626,7 @@ public static void uint3x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_mul_wide_scalar()
         {
             uint3x2 a0 = uint3x2(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563);
@@ -650,7 +650,7 @@ public static void uint3x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -674,7 +674,7 @@ public static void uint3x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_div_wide_wide()
         {
             uint3x2 a0 = uint3x2(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420);
@@ -698,7 +698,7 @@ public static void uint3x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_div_wide_scalar()
         {
             uint3x2 a0 = uint3x2(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346);
@@ -722,7 +722,7 @@ public static void uint3x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -746,7 +746,7 @@ public static void uint3x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_mod_wide_wide()
         {
             uint3x2 a0 = uint3x2(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627);
@@ -770,7 +770,7 @@ public static void uint3x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_mod_wide_scalar()
         {
             uint3x2 a0 = uint3x2(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846);
@@ -794,7 +794,7 @@ public static void uint3x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -818,7 +818,7 @@ public static void uint3x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_plus()
         {
             uint3x2 a0 = uint3x2(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277);
@@ -838,7 +838,7 @@ public static void uint3x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_neg()
         {
             uint3x2 a0 = uint3x2(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493);
@@ -858,7 +858,7 @@ public static void uint3x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_prefix_inc()
         {
             uint3x2 a0 = uint3x2(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550);
@@ -878,7 +878,7 @@ public static void uint3x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_postfix_inc()
         {
             uint3x2 a0 = uint3x2(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229);
@@ -898,7 +898,7 @@ public static void uint3x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_prefix_dec()
         {
             uint3x2 a0 = uint3x2(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159);
@@ -918,7 +918,7 @@ public static void uint3x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_postfix_dec()
         {
             uint3x2 a0 = uint3x2(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869);
@@ -938,7 +938,7 @@ public static void uint3x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_bitwise_and_wide_wide()
         {
             uint3x2 a0 = uint3x2(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515);
@@ -962,7 +962,7 @@ public static void uint3x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_bitwise_and_wide_scalar()
         {
             uint3x2 a0 = uint3x2(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838);
@@ -986,7 +986,7 @@ public static void uint3x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1010,7 +1010,7 @@ public static void uint3x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_bitwise_or_wide_wide()
         {
             uint3x2 a0 = uint3x2(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930);
@@ -1034,7 +1034,7 @@ public static void uint3x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_bitwise_or_wide_scalar()
         {
             uint3x2 a0 = uint3x2(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467);
@@ -1058,7 +1058,7 @@ public static void uint3x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1082,7 +1082,7 @@ public static void uint3x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_bitwise_xor_wide_wide()
         {
             uint3x2 a0 = uint3x2(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850);
@@ -1106,7 +1106,7 @@ public static void uint3x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_bitwise_xor_wide_scalar()
         {
             uint3x2 a0 = uint3x2(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661);
@@ -1130,7 +1130,7 @@ public static void uint3x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1154,7 +1154,7 @@ public static void uint3x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_left_shift()
         {
             uint3x2 a0 = uint3x2(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593);
@@ -1178,7 +1178,7 @@ public static void uint3x2_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_right_shift()
         {
             uint3x2 a0 = uint3x2(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842);
@@ -1202,7 +1202,7 @@ public static void uint3x2_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x2_operator_bitwise_not()
         {
             uint3x2 a0 = uint3x2(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399);
@@ -1222,7 +1222,7 @@ public static void uint3x2_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void uint3x2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new uint3x2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestUint3x3.gen.cs b/src/Tests/Tests/Shared/TestUint3x3.gen.cs
index 5861b8a2..6e679bba 100644
--- a/src/Tests/Tests/Shared/TestUint3x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint3x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint3x3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_zero()
         {
             TestUtils.AreEqual(0u, uint3x3.zero.c0.x);
@@ -29,7 +29,7 @@ public static void uint3x3_zero()
             TestUtils.AreEqual(0u, uint3x3.zero.c2.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_identity()
         {
             TestUtils.AreEqual(1u, uint3x3.identity.c0.x);
@@ -43,7 +43,7 @@ public static void uint3x3_identity()
             TestUtils.AreEqual(1u, uint3x3.identity.c2.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_equal_wide_wide()
         {
             uint3x3 a0 = uint3x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367);
@@ -67,7 +67,7 @@ public static void uint3x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_equal_wide_scalar()
         {
             uint3x3 a0 = uint3x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998);
@@ -91,7 +91,7 @@ public static void uint3x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -115,7 +115,7 @@ public static void uint3x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_not_equal_wide_wide()
         {
             uint3x3 a0 = uint3x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678);
@@ -139,7 +139,7 @@ public static void uint3x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_not_equal_wide_scalar()
         {
             uint3x3 a0 = uint3x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423);
@@ -163,7 +163,7 @@ public static void uint3x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -187,7 +187,7 @@ public static void uint3x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_less_wide_wide()
         {
             uint3x3 a0 = uint3x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312);
@@ -211,7 +211,7 @@ public static void uint3x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_less_wide_scalar()
         {
             uint3x3 a0 = uint3x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597);
@@ -235,7 +235,7 @@ public static void uint3x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -259,7 +259,7 @@ public static void uint3x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_greater_wide_wide()
         {
             uint3x3 a0 = uint3x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133);
@@ -283,7 +283,7 @@ public static void uint3x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_greater_wide_scalar()
         {
             uint3x3 a0 = uint3x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855);
@@ -307,7 +307,7 @@ public static void uint3x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -331,7 +331,7 @@ public static void uint3x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_less_equal_wide_wide()
         {
             uint3x3 a0 = uint3x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541);
@@ -355,7 +355,7 @@ public static void uint3x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_less_equal_wide_scalar()
         {
             uint3x3 a0 = uint3x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375);
@@ -379,7 +379,7 @@ public static void uint3x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -403,7 +403,7 @@ public static void uint3x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_greater_equal_wide_wide()
         {
             uint3x3 a0 = uint3x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826);
@@ -427,7 +427,7 @@ public static void uint3x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_greater_equal_wide_scalar()
         {
             uint3x3 a0 = uint3x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669);
@@ -451,7 +451,7 @@ public static void uint3x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -475,7 +475,7 @@ public static void uint3x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_add_wide_wide()
         {
             uint3x3 a0 = uint3x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600);
@@ -499,7 +499,7 @@ public static void uint3x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_add_wide_scalar()
         {
             uint3x3 a0 = uint3x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008);
@@ -523,7 +523,7 @@ public static void uint3x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -547,7 +547,7 @@ public static void uint3x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_sub_wide_wide()
         {
             uint3x3 a0 = uint3x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315);
@@ -571,7 +571,7 @@ public static void uint3x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_sub_wide_scalar()
         {
             uint3x3 a0 = uint3x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113);
@@ -595,7 +595,7 @@ public static void uint3x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -619,7 +619,7 @@ public static void uint3x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_mul_wide_wide()
         {
             uint3x3 a0 = uint3x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583);
@@ -643,7 +643,7 @@ public static void uint3x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_mul_wide_scalar()
         {
             uint3x3 a0 = uint3x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059);
@@ -667,7 +667,7 @@ public static void uint3x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -691,7 +691,7 @@ public static void uint3x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_div_wide_wide()
         {
             uint3x3 a0 = uint3x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195);
@@ -715,7 +715,7 @@ public static void uint3x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_div_wide_scalar()
         {
             uint3x3 a0 = uint3x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136);
@@ -739,7 +739,7 @@ public static void uint3x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -763,7 +763,7 @@ public static void uint3x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_mod_wide_wide()
         {
             uint3x3 a0 = uint3x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101);
@@ -787,7 +787,7 @@ public static void uint3x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_mod_wide_scalar()
         {
             uint3x3 a0 = uint3x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144);
@@ -811,7 +811,7 @@ public static void uint3x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -835,7 +835,7 @@ public static void uint3x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_plus()
         {
             uint3x3 a0 = uint3x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671);
@@ -855,7 +855,7 @@ public static void uint3x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_neg()
         {
             uint3x3 a0 = uint3x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525);
@@ -875,7 +875,7 @@ public static void uint3x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_prefix_inc()
         {
             uint3x3 a0 = uint3x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994);
@@ -895,7 +895,7 @@ public static void uint3x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_postfix_inc()
         {
             uint3x3 a0 = uint3x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247);
@@ -915,7 +915,7 @@ public static void uint3x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_prefix_dec()
         {
             uint3x3 a0 = uint3x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745);
@@ -935,7 +935,7 @@ public static void uint3x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_postfix_dec()
         {
             uint3x3 a0 = uint3x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889);
@@ -955,7 +955,7 @@ public static void uint3x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_bitwise_and_wide_wide()
         {
             uint3x3 a0 = uint3x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656);
@@ -979,7 +979,7 @@ public static void uint3x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_bitwise_and_wide_scalar()
         {
             uint3x3 a0 = uint3x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263);
@@ -1003,7 +1003,7 @@ public static void uint3x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1027,7 +1027,7 @@ public static void uint3x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_bitwise_or_wide_wide()
         {
             uint3x3 a0 = uint3x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869);
@@ -1051,7 +1051,7 @@ public static void uint3x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_bitwise_or_wide_scalar()
         {
             uint3x3 a0 = uint3x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307);
@@ -1075,7 +1075,7 @@ public static void uint3x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1099,7 +1099,7 @@ public static void uint3x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_bitwise_xor_wide_wide()
         {
             uint3x3 a0 = uint3x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251);
@@ -1123,7 +1123,7 @@ public static void uint3x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_bitwise_xor_wide_scalar()
         {
             uint3x3 a0 = uint3x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873);
@@ -1147,7 +1147,7 @@ public static void uint3x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1171,7 +1171,7 @@ public static void uint3x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_left_shift()
         {
             uint3x3 a0 = uint3x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727);
@@ -1195,7 +1195,7 @@ public static void uint3x3_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_right_shift()
         {
             uint3x3 a0 = uint3x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393);
@@ -1219,7 +1219,7 @@ public static void uint3x3_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x3_operator_bitwise_not()
         {
             uint3x3 a0 = uint3x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628);
@@ -1239,7 +1239,7 @@ public static void uint3x3_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void uint3x3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new uint3x3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestUint3x4.gen.cs b/src/Tests/Tests/Shared/TestUint3x4.gen.cs
index 9832a2a7..00c414a7 100644
--- a/src/Tests/Tests/Shared/TestUint3x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint3x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint3x4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_zero()
         {
             TestUtils.AreEqual(0u, uint3x4.zero.c0.x);
@@ -32,7 +32,7 @@ public static void uint3x4_zero()
             TestUtils.AreEqual(0u, uint3x4.zero.c3.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_equal_wide_wide()
         {
             uint3x4 a0 = uint3x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837);
@@ -56,7 +56,7 @@ public static void uint3x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_equal_wide_scalar()
         {
             uint3x4 a0 = uint3x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137);
@@ -80,7 +80,7 @@ public static void uint3x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -104,7 +104,7 @@ public static void uint3x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_not_equal_wide_wide()
         {
             uint3x4 a0 = uint3x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545);
@@ -128,7 +128,7 @@ public static void uint3x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_not_equal_wide_scalar()
         {
             uint3x4 a0 = uint3x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494);
@@ -152,7 +152,7 @@ public static void uint3x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -176,7 +176,7 @@ public static void uint3x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_less_wide_wide()
         {
             uint3x4 a0 = uint3x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069);
@@ -200,7 +200,7 @@ public static void uint3x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_less_wide_scalar()
         {
             uint3x4 a0 = uint3x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417);
@@ -224,7 +224,7 @@ public static void uint3x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -248,7 +248,7 @@ public static void uint3x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_greater_wide_wide()
         {
             uint3x4 a0 = uint3x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903);
@@ -272,7 +272,7 @@ public static void uint3x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_greater_wide_scalar()
         {
             uint3x4 a0 = uint3x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960);
@@ -296,7 +296,7 @@ public static void uint3x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -320,7 +320,7 @@ public static void uint3x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_less_equal_wide_wide()
         {
             uint3x4 a0 = uint3x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946);
@@ -344,7 +344,7 @@ public static void uint3x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_less_equal_wide_scalar()
         {
             uint3x4 a0 = uint3x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501);
@@ -368,7 +368,7 @@ public static void uint3x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -392,7 +392,7 @@ public static void uint3x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_greater_equal_wide_wide()
         {
             uint3x4 a0 = uint3x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752);
@@ -416,7 +416,7 @@ public static void uint3x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_greater_equal_wide_scalar()
         {
             uint3x4 a0 = uint3x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390);
@@ -440,7 +440,7 @@ public static void uint3x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -464,7 +464,7 @@ public static void uint3x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_add_wide_wide()
         {
             uint3x4 a0 = uint3x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462);
@@ -488,7 +488,7 @@ public static void uint3x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_add_wide_scalar()
         {
             uint3x4 a0 = uint3x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642);
@@ -512,7 +512,7 @@ public static void uint3x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -536,7 +536,7 @@ public static void uint3x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_sub_wide_wide()
         {
             uint3x4 a0 = uint3x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285);
@@ -560,7 +560,7 @@ public static void uint3x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_sub_wide_scalar()
         {
             uint3x4 a0 = uint3x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508);
@@ -584,7 +584,7 @@ public static void uint3x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -608,7 +608,7 @@ public static void uint3x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_mul_wide_wide()
         {
             uint3x4 a0 = uint3x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842);
@@ -632,7 +632,7 @@ public static void uint3x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_mul_wide_scalar()
         {
             uint3x4 a0 = uint3x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203);
@@ -656,7 +656,7 @@ public static void uint3x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -680,7 +680,7 @@ public static void uint3x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_div_wide_wide()
         {
             uint3x4 a0 = uint3x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736);
@@ -704,7 +704,7 @@ public static void uint3x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_div_wide_scalar()
         {
             uint3x4 a0 = uint3x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377);
@@ -728,7 +728,7 @@ public static void uint3x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -752,7 +752,7 @@ public static void uint3x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_mod_wide_wide()
         {
             uint3x4 a0 = uint3x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293);
@@ -776,7 +776,7 @@ public static void uint3x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_mod_wide_scalar()
         {
             uint3x4 a0 = uint3x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785);
@@ -800,7 +800,7 @@ public static void uint3x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -824,7 +824,7 @@ public static void uint3x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_plus()
         {
             uint3x4 a0 = uint3x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223);
@@ -844,7 +844,7 @@ public static void uint3x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_neg()
         {
             uint3x4 a0 = uint3x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822);
@@ -864,7 +864,7 @@ public static void uint3x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_prefix_inc()
         {
             uint3x4 a0 = uint3x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735);
@@ -884,7 +884,7 @@ public static void uint3x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_postfix_inc()
         {
             uint3x4 a0 = uint3x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446);
@@ -904,7 +904,7 @@ public static void uint3x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_prefix_dec()
         {
             uint3x4 a0 = uint3x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220);
@@ -924,7 +924,7 @@ public static void uint3x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_postfix_dec()
         {
             uint3x4 a0 = uint3x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851);
@@ -944,7 +944,7 @@ public static void uint3x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_bitwise_and_wide_wide()
         {
             uint3x4 a0 = uint3x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302);
@@ -968,7 +968,7 @@ public static void uint3x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_bitwise_and_wide_scalar()
         {
             uint3x4 a0 = uint3x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546);
@@ -992,7 +992,7 @@ public static void uint3x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1016,7 +1016,7 @@ public static void uint3x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_bitwise_or_wide_wide()
         {
             uint3x4 a0 = uint3x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227);
@@ -1040,7 +1040,7 @@ public static void uint3x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_bitwise_or_wide_scalar()
         {
             uint3x4 a0 = uint3x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676);
@@ -1064,7 +1064,7 @@ public static void uint3x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1088,7 +1088,7 @@ public static void uint3x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_bitwise_xor_wide_wide()
         {
             uint3x4 a0 = uint3x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919);
@@ -1112,7 +1112,7 @@ public static void uint3x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_bitwise_xor_wide_scalar()
         {
             uint3x4 a0 = uint3x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786);
@@ -1136,7 +1136,7 @@ public static void uint3x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1160,7 +1160,7 @@ public static void uint3x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_left_shift()
         {
             uint3x4 a0 = uint3x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902);
@@ -1184,7 +1184,7 @@ public static void uint3x4_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_right_shift()
         {
             uint3x4 a0 = uint3x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878);
@@ -1208,7 +1208,7 @@ public static void uint3x4_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3x4_operator_bitwise_not()
         {
             uint3x4 a0 = uint3x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785);
@@ -1228,7 +1228,7 @@ public static void uint3x4_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void uint3x4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new uint3x4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestUint4.gen.cs b/src/Tests/Tests/Shared/TestUint4.gen.cs
index 49e0be49..833012cd 100644
--- a/src/Tests/Tests/Shared/TestUint4.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_zero()
         {
             TestUtils.AreEqual(0u, uint4.zero.x);
@@ -24,7 +24,7 @@ public static void uint4_zero()
             TestUtils.AreEqual(0u, uint4.zero.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_constructor()
         {
             uint4 a = new uint4(1, 2, 3, 4);
@@ -34,7 +34,7 @@ public static void uint4_constructor()
             TestUtils.AreEqual(4, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_scalar_constructor()
         {
             uint4 a = new uint4(17u);
@@ -44,7 +44,7 @@ public static void uint4_scalar_constructor()
             TestUtils.AreEqual(17u, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_static_constructor()
         {
             uint4 a = uint4(1, 2, 3, 4);
@@ -54,7 +54,7 @@ public static void uint4_static_constructor()
             TestUtils.AreEqual(4, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_static_scalar_constructor()
         {
             uint4 a = uint4(17u);
@@ -64,7 +64,7 @@ public static void uint4_static_scalar_constructor()
             TestUtils.AreEqual(17u, a.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_equal_wide_wide()
         {
             uint4 a0 = uint4(2105871082, 35218899, 1550755093, 764676020);
@@ -88,7 +88,7 @@ public static void uint4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_equal_wide_scalar()
         {
             uint4 a0 = uint4(437822262, 2020661134, 541786900, 853113810);
@@ -112,7 +112,7 @@ public static void uint4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -136,7 +136,7 @@ public static void uint4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_not_equal_wide_wide()
         {
             uint4 a0 = uint4(1977284100, 1293292704, 1547283851, 422428953);
@@ -160,7 +160,7 @@ public static void uint4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_not_equal_wide_scalar()
         {
             uint4 a0 = uint4(1038269360, 1427812625, 103361237, 1347017023);
@@ -184,7 +184,7 @@ public static void uint4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -208,7 +208,7 @@ public static void uint4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_less_wide_wide()
         {
             uint4 a0 = uint4(1486550609, 1779244308, 1602148045, 1614085440);
@@ -232,7 +232,7 @@ public static void uint4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_less_wide_scalar()
         {
             uint4 a0 = uint4(796797557, 670113454, 933579492, 278884514);
@@ -256,7 +256,7 @@ public static void uint4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -280,7 +280,7 @@ public static void uint4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_greater_wide_wide()
         {
             uint4 a0 = uint4(2087717754, 1725569452, 1298066182, 1693943616);
@@ -304,7 +304,7 @@ public static void uint4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_greater_wide_scalar()
         {
             uint4 a0 = uint4(1208626274, 239697208, 1979453345, 1253474001);
@@ -328,7 +328,7 @@ public static void uint4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -352,7 +352,7 @@ public static void uint4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_less_equal_wide_wide()
         {
             uint4 a0 = uint4(154092149, 1515170149, 1083970332, 785807178);
@@ -376,7 +376,7 @@ public static void uint4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_less_equal_wide_scalar()
         {
             uint4 a0 = uint4(1479531977, 1427983411, 415250630, 1245345407);
@@ -400,7 +400,7 @@ public static void uint4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -424,7 +424,7 @@ public static void uint4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_greater_equal_wide_wide()
         {
             uint4 a0 = uint4(8538378, 2131749726, 265427108, 523609761);
@@ -448,7 +448,7 @@ public static void uint4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_greater_equal_wide_scalar()
         {
             uint4 a0 = uint4(2049236663, 182691143, 634973382, 1197012109);
@@ -472,7 +472,7 @@ public static void uint4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -496,7 +496,7 @@ public static void uint4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_add_wide_wide()
         {
             uint4 a0 = uint4(2135171378, 21433296, 1954723494, 683604307);
@@ -520,7 +520,7 @@ public static void uint4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_add_wide_scalar()
         {
             uint4 a0 = uint4(665815972, 1783729250, 1591678394, 1284528538);
@@ -544,7 +544,7 @@ public static void uint4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -568,7 +568,7 @@ public static void uint4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_sub_wide_wide()
         {
             uint4 a0 = uint4(1410318491, 1097280168, 1827039044, 28881338);
@@ -592,7 +592,7 @@ public static void uint4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_sub_wide_scalar()
         {
             uint4 a0 = uint4(1508669340, 1594795463, 266707545, 643102647);
@@ -616,7 +616,7 @@ public static void uint4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -640,7 +640,7 @@ public static void uint4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_mul_wide_wide()
         {
             uint4 a0 = uint4(61417577, 219585476, 1362520891, 1511084277);
@@ -664,7 +664,7 @@ public static void uint4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_mul_wide_scalar()
         {
             uint4 a0 = uint4(871746615, 492532311, 570557670, 2142306629);
@@ -688,7 +688,7 @@ public static void uint4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -712,7 +712,7 @@ public static void uint4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_div_wide_wide()
         {
             uint4 a0 = uint4(333171510, 858154903, 1181365836, 671357749);
@@ -736,7 +736,7 @@ public static void uint4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_div_wide_scalar()
         {
             uint4 a0 = uint4(1433072926, 1073958635, 1195142312, 536596719);
@@ -760,7 +760,7 @@ public static void uint4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -784,7 +784,7 @@ public static void uint4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_mod_wide_wide()
         {
             uint4 a0 = uint4(258342924, 1454754891, 723352342, 1981431473);
@@ -808,7 +808,7 @@ public static void uint4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_mod_wide_scalar()
         {
             uint4 a0 = uint4(560988938, 629524514, 767711194, 434281967);
@@ -832,7 +832,7 @@ public static void uint4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -856,7 +856,7 @@ public static void uint4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_plus()
         {
             uint4 a0 = uint4(195392567, 222719748, 1002351013, 1570765263);
@@ -876,7 +876,7 @@ public static void uint4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_neg()
         {
             uint4 a0 = uint4(1385088677, 94114564, 1350664872, 1458616659);
@@ -896,7 +896,7 @@ public static void uint4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_prefix_inc()
         {
             uint4 a0 = uint4(780471723, 954741756, 272723451, 2142862245);
@@ -916,7 +916,7 @@ public static void uint4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_postfix_inc()
         {
             uint4 a0 = uint4(241865086, 2145821641, 1596166022, 803592338);
@@ -936,7 +936,7 @@ public static void uint4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_prefix_dec()
         {
             uint4 a0 = uint4(1331961415, 1612382200, 1401591249, 2042075388);
@@ -956,7 +956,7 @@ public static void uint4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_postfix_dec()
         {
             uint4 a0 = uint4(1870005937, 1708534798, 704493460, 462940703);
@@ -976,7 +976,7 @@ public static void uint4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_bitwise_and_wide_wide()
         {
             uint4 a0 = uint4(1055241304, 859321394, 1088358961, 2090949513);
@@ -1000,7 +1000,7 @@ public static void uint4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_bitwise_and_wide_scalar()
         {
             uint4 a0 = uint4(1513158868, 284695609, 734595037, 1566510707);
@@ -1024,7 +1024,7 @@ public static void uint4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1048,7 +1048,7 @@ public static void uint4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_bitwise_or_wide_wide()
         {
             uint4 a0 = uint4(1920951869, 1750772852, 1420019191, 732977093);
@@ -1072,7 +1072,7 @@ public static void uint4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_bitwise_or_wide_scalar()
         {
             uint4 a0 = uint4(1295304853, 1307252624, 350194630, 1128063578);
@@ -1096,7 +1096,7 @@ public static void uint4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1120,7 +1120,7 @@ public static void uint4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_bitwise_xor_wide_wide()
         {
             uint4 a0 = uint4(1843655608, 362425681, 640805534, 1342040268);
@@ -1144,7 +1144,7 @@ public static void uint4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_bitwise_xor_wide_scalar()
         {
             uint4 a0 = uint4(169345668, 176087064, 2084362901, 1663924004);
@@ -1168,7 +1168,7 @@ public static void uint4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1192,7 +1192,7 @@ public static void uint4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_left_shift()
         {
             uint4 a0 = uint4(1129100049, 829482269, 1571297368, 443753193);
@@ -1216,7 +1216,7 @@ public static void uint4_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_right_shift()
         {
             uint4 a0 = uint4(809126085, 908563670, 763568837, 1986717290);
@@ -1240,7 +1240,7 @@ public static void uint4_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_operator_bitwise_not()
         {
             uint4 a0 = uint4(111796841, 603562399, 745091931, 853183268);
@@ -1260,7 +1260,7 @@ public static void uint4_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_shuffle_result_1()
         {
             uint4 a = uint4(0, 1, 2, 3);
@@ -1276,7 +1276,7 @@ public static void uint4_shuffle_result_1()
             TestUtils.AreEqual((7), shuffle(a, b, ShuffleComponent.RightW));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_shuffle_result_2()
         {
             uint4 a = uint4(0, 1, 2, 3);
@@ -1300,7 +1300,7 @@ public static void uint4_shuffle_result_2()
             TestUtils.AreEqual(uint2(1, 3), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_shuffle_result_3()
         {
             uint4 a = uint4(0, 1, 2, 3);
@@ -1324,7 +1324,7 @@ public static void uint4_shuffle_result_3()
             TestUtils.AreEqual(uint3(5, 1, 7), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_shuffle_result_4()
         {
             uint4 a = uint4(0, 1, 2, 3);
@@ -1348,7 +1348,7 @@ public static void uint4_shuffle_result_4()
             TestUtils.AreEqual(uint4(3, 7, 1, 5), shuffle(a, b, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.LeftY, ShuffleComponent.RightY));
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void uint4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new uint4().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestUint4x2.gen.cs b/src/Tests/Tests/Shared/TestUint4x2.gen.cs
index 4cf1fc14..9d2bba1f 100644
--- a/src/Tests/Tests/Shared/TestUint4x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint4x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint4x2
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_zero()
         {
             TestUtils.AreEqual(0u, uint4x2.zero.c0.x);
@@ -28,7 +28,7 @@ public static void uint4x2_zero()
             TestUtils.AreEqual(0u, uint4x2.zero.c1.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_equal_wide_wide()
         {
             uint4x2 a0 = uint4x2(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316);
@@ -52,7 +52,7 @@ public static void uint4x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_equal_wide_scalar()
         {
             uint4x2 a0 = uint4x2(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849);
@@ -76,7 +76,7 @@ public static void uint4x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -100,7 +100,7 @@ public static void uint4x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_not_equal_wide_wide()
         {
             uint4x2 a0 = uint4x2(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074);
@@ -124,7 +124,7 @@ public static void uint4x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_not_equal_wide_scalar()
         {
             uint4x2 a0 = uint4x2(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717);
@@ -148,7 +148,7 @@ public static void uint4x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -172,7 +172,7 @@ public static void uint4x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_less_wide_wide()
         {
             uint4x2 a0 = uint4x2(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431);
@@ -196,7 +196,7 @@ public static void uint4x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_less_wide_scalar()
         {
             uint4x2 a0 = uint4x2(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600);
@@ -220,7 +220,7 @@ public static void uint4x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -244,7 +244,7 @@ public static void uint4x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_greater_wide_wide()
         {
             uint4x2 a0 = uint4x2(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508);
@@ -268,7 +268,7 @@ public static void uint4x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_greater_wide_scalar()
         {
             uint4x2 a0 = uint4x2(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098);
@@ -292,7 +292,7 @@ public static void uint4x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -316,7 +316,7 @@ public static void uint4x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_less_equal_wide_wide()
         {
             uint4x2 a0 = uint4x2(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725);
@@ -340,7 +340,7 @@ public static void uint4x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_less_equal_wide_scalar()
         {
             uint4x2 a0 = uint4x2(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307);
@@ -364,7 +364,7 @@ public static void uint4x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -388,7 +388,7 @@ public static void uint4x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_greater_equal_wide_wide()
         {
             uint4x2 a0 = uint4x2(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970);
@@ -412,7 +412,7 @@ public static void uint4x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_greater_equal_wide_scalar()
         {
             uint4x2 a0 = uint4x2(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187);
@@ -436,7 +436,7 @@ public static void uint4x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -460,7 +460,7 @@ public static void uint4x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_add_wide_wide()
         {
             uint4x2 a0 = uint4x2(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062);
@@ -484,7 +484,7 @@ public static void uint4x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_add_wide_scalar()
         {
             uint4x2 a0 = uint4x2(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017);
@@ -508,7 +508,7 @@ public static void uint4x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -532,7 +532,7 @@ public static void uint4x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_sub_wide_wide()
         {
             uint4x2 a0 = uint4x2(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215);
@@ -556,7 +556,7 @@ public static void uint4x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_sub_wide_scalar()
         {
             uint4x2 a0 = uint4x2(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511);
@@ -580,7 +580,7 @@ public static void uint4x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -604,7 +604,7 @@ public static void uint4x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_mul_wide_wide()
         {
             uint4x2 a0 = uint4x2(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644);
@@ -628,7 +628,7 @@ public static void uint4x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_mul_wide_scalar()
         {
             uint4x2 a0 = uint4x2(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514);
@@ -652,7 +652,7 @@ public static void uint4x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -676,7 +676,7 @@ public static void uint4x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_div_wide_wide()
         {
             uint4x2 a0 = uint4x2(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814);
@@ -700,7 +700,7 @@ public static void uint4x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_div_wide_scalar()
         {
             uint4x2 a0 = uint4x2(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670);
@@ -724,7 +724,7 @@ public static void uint4x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -748,7 +748,7 @@ public static void uint4x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_mod_wide_wide()
         {
             uint4x2 a0 = uint4x2(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004);
@@ -772,7 +772,7 @@ public static void uint4x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_mod_wide_scalar()
         {
             uint4x2 a0 = uint4x2(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916);
@@ -796,7 +796,7 @@ public static void uint4x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -820,7 +820,7 @@ public static void uint4x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_plus()
         {
             uint4x2 a0 = uint4x2(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785);
@@ -840,7 +840,7 @@ public static void uint4x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_neg()
         {
             uint4x2 a0 = uint4x2(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961);
@@ -860,7 +860,7 @@ public static void uint4x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_prefix_inc()
         {
             uint4x2 a0 = uint4x2(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162);
@@ -880,7 +880,7 @@ public static void uint4x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_postfix_inc()
         {
             uint4x2 a0 = uint4x2(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244);
@@ -900,7 +900,7 @@ public static void uint4x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_prefix_dec()
         {
             uint4x2 a0 = uint4x2(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664);
@@ -920,7 +920,7 @@ public static void uint4x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_postfix_dec()
         {
             uint4x2 a0 = uint4x2(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351);
@@ -940,7 +940,7 @@ public static void uint4x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_bitwise_and_wide_wide()
         {
             uint4x2 a0 = uint4x2(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753);
@@ -964,7 +964,7 @@ public static void uint4x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_bitwise_and_wide_scalar()
         {
             uint4x2 a0 = uint4x2(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908);
@@ -988,7 +988,7 @@ public static void uint4x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1012,7 +1012,7 @@ public static void uint4x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_bitwise_or_wide_wide()
         {
             uint4x2 a0 = uint4x2(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323);
@@ -1036,7 +1036,7 @@ public static void uint4x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_bitwise_or_wide_scalar()
         {
             uint4x2 a0 = uint4x2(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350);
@@ -1060,7 +1060,7 @@ public static void uint4x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1084,7 +1084,7 @@ public static void uint4x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_bitwise_xor_wide_wide()
         {
             uint4x2 a0 = uint4x2(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658);
@@ -1108,7 +1108,7 @@ public static void uint4x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_bitwise_xor_wide_scalar()
         {
             uint4x2 a0 = uint4x2(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783);
@@ -1132,7 +1132,7 @@ public static void uint4x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1156,7 +1156,7 @@ public static void uint4x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_left_shift()
         {
             uint4x2 a0 = uint4x2(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862);
@@ -1180,7 +1180,7 @@ public static void uint4x2_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_right_shift()
         {
             uint4x2 a0 = uint4x2(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632);
@@ -1204,7 +1204,7 @@ public static void uint4x2_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x2_operator_bitwise_not()
         {
             uint4x2 a0 = uint4x2(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135);
@@ -1224,7 +1224,7 @@ public static void uint4x2_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void uint4x2_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new uint4x2().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestUint4x3.gen.cs b/src/Tests/Tests/Shared/TestUint4x3.gen.cs
index 0bcde5e9..bc2aba8a 100644
--- a/src/Tests/Tests/Shared/TestUint4x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint4x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint4x3
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_zero()
         {
             TestUtils.AreEqual(0u, uint4x3.zero.c0.x);
@@ -32,7 +32,7 @@ public static void uint4x3_zero()
             TestUtils.AreEqual(0u, uint4x3.zero.c2.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_equal_wide_wide()
         {
             uint4x3 a0 = uint4x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837);
@@ -56,7 +56,7 @@ public static void uint4x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_equal_wide_scalar()
         {
             uint4x3 a0 = uint4x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137);
@@ -80,7 +80,7 @@ public static void uint4x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -104,7 +104,7 @@ public static void uint4x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_not_equal_wide_wide()
         {
             uint4x3 a0 = uint4x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545);
@@ -128,7 +128,7 @@ public static void uint4x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_not_equal_wide_scalar()
         {
             uint4x3 a0 = uint4x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494);
@@ -152,7 +152,7 @@ public static void uint4x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -176,7 +176,7 @@ public static void uint4x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_less_wide_wide()
         {
             uint4x3 a0 = uint4x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069);
@@ -200,7 +200,7 @@ public static void uint4x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_less_wide_scalar()
         {
             uint4x3 a0 = uint4x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417);
@@ -224,7 +224,7 @@ public static void uint4x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -248,7 +248,7 @@ public static void uint4x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_greater_wide_wide()
         {
             uint4x3 a0 = uint4x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903);
@@ -272,7 +272,7 @@ public static void uint4x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_greater_wide_scalar()
         {
             uint4x3 a0 = uint4x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960);
@@ -296,7 +296,7 @@ public static void uint4x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -320,7 +320,7 @@ public static void uint4x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_less_equal_wide_wide()
         {
             uint4x3 a0 = uint4x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946);
@@ -344,7 +344,7 @@ public static void uint4x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_less_equal_wide_scalar()
         {
             uint4x3 a0 = uint4x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501);
@@ -368,7 +368,7 @@ public static void uint4x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -392,7 +392,7 @@ public static void uint4x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_greater_equal_wide_wide()
         {
             uint4x3 a0 = uint4x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752);
@@ -416,7 +416,7 @@ public static void uint4x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_greater_equal_wide_scalar()
         {
             uint4x3 a0 = uint4x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390);
@@ -440,7 +440,7 @@ public static void uint4x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -464,7 +464,7 @@ public static void uint4x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_add_wide_wide()
         {
             uint4x3 a0 = uint4x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462);
@@ -488,7 +488,7 @@ public static void uint4x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_add_wide_scalar()
         {
             uint4x3 a0 = uint4x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642);
@@ -512,7 +512,7 @@ public static void uint4x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -536,7 +536,7 @@ public static void uint4x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_sub_wide_wide()
         {
             uint4x3 a0 = uint4x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285);
@@ -560,7 +560,7 @@ public static void uint4x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_sub_wide_scalar()
         {
             uint4x3 a0 = uint4x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508);
@@ -584,7 +584,7 @@ public static void uint4x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -608,7 +608,7 @@ public static void uint4x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_mul_wide_wide()
         {
             uint4x3 a0 = uint4x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842);
@@ -632,7 +632,7 @@ public static void uint4x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_mul_wide_scalar()
         {
             uint4x3 a0 = uint4x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203);
@@ -656,7 +656,7 @@ public static void uint4x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -680,7 +680,7 @@ public static void uint4x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_div_wide_wide()
         {
             uint4x3 a0 = uint4x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736);
@@ -704,7 +704,7 @@ public static void uint4x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_div_wide_scalar()
         {
             uint4x3 a0 = uint4x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377);
@@ -728,7 +728,7 @@ public static void uint4x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -752,7 +752,7 @@ public static void uint4x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_mod_wide_wide()
         {
             uint4x3 a0 = uint4x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293);
@@ -776,7 +776,7 @@ public static void uint4x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_mod_wide_scalar()
         {
             uint4x3 a0 = uint4x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785);
@@ -800,7 +800,7 @@ public static void uint4x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -824,7 +824,7 @@ public static void uint4x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_plus()
         {
             uint4x3 a0 = uint4x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223);
@@ -844,7 +844,7 @@ public static void uint4x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_neg()
         {
             uint4x3 a0 = uint4x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822);
@@ -864,7 +864,7 @@ public static void uint4x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_prefix_inc()
         {
             uint4x3 a0 = uint4x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735);
@@ -884,7 +884,7 @@ public static void uint4x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_postfix_inc()
         {
             uint4x3 a0 = uint4x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446);
@@ -904,7 +904,7 @@ public static void uint4x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_prefix_dec()
         {
             uint4x3 a0 = uint4x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220);
@@ -924,7 +924,7 @@ public static void uint4x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_postfix_dec()
         {
             uint4x3 a0 = uint4x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851);
@@ -944,7 +944,7 @@ public static void uint4x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_bitwise_and_wide_wide()
         {
             uint4x3 a0 = uint4x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302);
@@ -968,7 +968,7 @@ public static void uint4x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_bitwise_and_wide_scalar()
         {
             uint4x3 a0 = uint4x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546);
@@ -992,7 +992,7 @@ public static void uint4x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1016,7 +1016,7 @@ public static void uint4x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_bitwise_or_wide_wide()
         {
             uint4x3 a0 = uint4x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227);
@@ -1040,7 +1040,7 @@ public static void uint4x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_bitwise_or_wide_scalar()
         {
             uint4x3 a0 = uint4x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676);
@@ -1064,7 +1064,7 @@ public static void uint4x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1088,7 +1088,7 @@ public static void uint4x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_bitwise_xor_wide_wide()
         {
             uint4x3 a0 = uint4x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919);
@@ -1112,7 +1112,7 @@ public static void uint4x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_bitwise_xor_wide_scalar()
         {
             uint4x3 a0 = uint4x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786);
@@ -1136,7 +1136,7 @@ public static void uint4x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1160,7 +1160,7 @@ public static void uint4x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_left_shift()
         {
             uint4x3 a0 = uint4x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902);
@@ -1184,7 +1184,7 @@ public static void uint4x3_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_right_shift()
         {
             uint4x3 a0 = uint4x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878);
@@ -1208,7 +1208,7 @@ public static void uint4x3_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x3_operator_bitwise_not()
         {
             uint4x3 a0 = uint4x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785);
@@ -1228,7 +1228,7 @@ public static void uint4x3_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void uint4x3_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new uint4x3().Equals((object)new int()));
diff --git a/src/Tests/Tests/Shared/TestUint4x4.gen.cs b/src/Tests/Tests/Shared/TestUint4x4.gen.cs
index 67f34ee1..03234c47 100644
--- a/src/Tests/Tests/Shared/TestUint4x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint4x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint4x4
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_zero()
         {
             TestUtils.AreEqual(0u, uint4x4.zero.c0.x);
@@ -36,7 +36,7 @@ public static void uint4x4_zero()
             TestUtils.AreEqual(0u, uint4x4.zero.c3.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_identity()
         {
             TestUtils.AreEqual(1u, uint4x4.identity.c0.x);
@@ -57,7 +57,7 @@ public static void uint4x4_identity()
             TestUtils.AreEqual(1u, uint4x4.identity.c3.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_equal_wide_wide()
         {
             uint4x4 a0 = uint4x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837, 1303661760, 2044073738, 370395888, 1822916805);
@@ -81,7 +81,7 @@ public static void uint4x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_equal_wide_scalar()
         {
             uint4x4 a0 = uint4x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137, 712957637, 2028784869, 1049962241, 1836975611);
@@ -105,7 +105,7 @@ public static void uint4x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -129,7 +129,7 @@ public static void uint4x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_not_equal_wide_wide()
         {
             uint4x4 a0 = uint4x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545, 1211445174, 1289303469, 1436402489, 1129570126);
@@ -153,7 +153,7 @@ public static void uint4x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_not_equal_wide_scalar()
         {
             uint4x4 a0 = uint4x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494, 507918242, 1702162286, 923269270, 166187260);
@@ -177,7 +177,7 @@ public static void uint4x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -201,7 +201,7 @@ public static void uint4x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_less_wide_wide()
         {
             uint4x4 a0 = uint4x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069, 840685445, 1220554047, 2013681746, 192965012);
@@ -225,7 +225,7 @@ public static void uint4x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_less_wide_scalar()
         {
             uint4x4 a0 = uint4x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417, 1857132231, 1909506562, 1294006045, 952084157);
@@ -249,7 +249,7 @@ public static void uint4x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -273,7 +273,7 @@ public static void uint4x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_greater_wide_wide()
         {
             uint4x4 a0 = uint4x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903, 2029731638, 1377214212, 1207816926, 474621063);
@@ -297,7 +297,7 @@ public static void uint4x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_greater_wide_scalar()
         {
             uint4x4 a0 = uint4x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960, 1850273578, 206147145, 325913453, 333381537);
@@ -321,7 +321,7 @@ public static void uint4x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -345,7 +345,7 @@ public static void uint4x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_less_equal_wide_wide()
         {
             uint4x4 a0 = uint4x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946, 1387761992, 195272789, 659549000, 888761458);
@@ -369,7 +369,7 @@ public static void uint4x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_less_equal_wide_scalar()
         {
             uint4x4 a0 = uint4x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501, 518127023, 1246249980, 1097326500, 1964410699);
@@ -393,7 +393,7 @@ public static void uint4x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -417,7 +417,7 @@ public static void uint4x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_greater_equal_wide_wide()
         {
             uint4x4 a0 = uint4x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752, 424526026, 788481984, 1662488497, 870326690);
@@ -441,7 +441,7 @@ public static void uint4x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_greater_equal_wide_scalar()
         {
             uint4x4 a0 = uint4x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390, 996159180, 2111455181, 727766399, 96217144);
@@ -465,7 +465,7 @@ public static void uint4x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -489,7 +489,7 @@ public static void uint4x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_add_wide_wide()
         {
             uint4x4 a0 = uint4x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462, 1218855698, 700538222, 1702057277, 1788251699);
@@ -513,7 +513,7 @@ public static void uint4x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_add_wide_scalar()
         {
             uint4x4 a0 = uint4x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642, 678921480, 625943813, 512157429, 1470648741);
@@ -537,7 +537,7 @@ public static void uint4x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -561,7 +561,7 @@ public static void uint4x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_sub_wide_wide()
         {
             uint4x4 a0 = uint4x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285, 1125909359, 1842588095, 848561896, 614448464);
@@ -585,7 +585,7 @@ public static void uint4x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_sub_wide_scalar()
         {
             uint4x4 a0 = uint4x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508, 1806482044, 1994553647, 2101812429, 1482736902);
@@ -609,7 +609,7 @@ public static void uint4x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -633,7 +633,7 @@ public static void uint4x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_mul_wide_wide()
         {
             uint4x4 a0 = uint4x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842, 522856538, 278370196, 289217012, 2083410174);
@@ -657,7 +657,7 @@ public static void uint4x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_mul_wide_scalar()
         {
             uint4x4 a0 = uint4x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203, 638897141, 268562104, 1007838321, 1163240135);
@@ -681,7 +681,7 @@ public static void uint4x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -705,7 +705,7 @@ public static void uint4x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_div_wide_wide()
         {
             uint4x4 a0 = uint4x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736, 200852358, 129983172, 500176108, 472051781);
@@ -729,7 +729,7 @@ public static void uint4x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_div_wide_scalar()
         {
             uint4x4 a0 = uint4x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377, 643754735, 2084019932, 2047825037, 458304263);
@@ -753,7 +753,7 @@ public static void uint4x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -777,7 +777,7 @@ public static void uint4x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_mod_wide_wide()
         {
             uint4x4 a0 = uint4x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293, 813624265, 1617478722, 498370451, 780075943);
@@ -801,7 +801,7 @@ public static void uint4x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_mod_wide_scalar()
         {
             uint4x4 a0 = uint4x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785, 327476870, 1617696916, 379853074, 477430114);
@@ -825,7 +825,7 @@ public static void uint4x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -849,7 +849,7 @@ public static void uint4x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_plus()
         {
             uint4x4 a0 = uint4x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223, 715660442, 1995564647, 69731564, 1317851903);
@@ -869,7 +869,7 @@ public static void uint4x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_neg()
         {
             uint4x4 a0 = uint4x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822, 2051940607, 1434247484, 485368391, 908365416);
@@ -889,7 +889,7 @@ public static void uint4x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_prefix_inc()
         {
             uint4x4 a0 = uint4x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735, 1584496757, 1170613526, 986715680, 1701179230);
@@ -909,7 +909,7 @@ public static void uint4x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_postfix_inc()
         {
             uint4x4 a0 = uint4x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446, 1343289659, 1227160199, 947635082, 137930180);
@@ -929,7 +929,7 @@ public static void uint4x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_prefix_dec()
         {
             uint4x4 a0 = uint4x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220, 312317355, 1027543764, 1595492535, 1426262619);
@@ -949,7 +949,7 @@ public static void uint4x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_postfix_dec()
         {
             uint4x4 a0 = uint4x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851, 653673271, 140452688, 1928164223, 1760916301);
@@ -969,7 +969,7 @@ public static void uint4x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_bitwise_and_wide_wide()
         {
             uint4x4 a0 = uint4x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302, 1929998247, 1504941434, 470682792, 713577376);
@@ -993,7 +993,7 @@ public static void uint4x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_bitwise_and_wide_scalar()
         {
             uint4x4 a0 = uint4x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546, 1873208293, 126982769, 651482651, 1383096952);
@@ -1017,7 +1017,7 @@ public static void uint4x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1041,7 +1041,7 @@ public static void uint4x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_bitwise_or_wide_wide()
         {
             uint4x4 a0 = uint4x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227, 1686257697, 2137727522, 1569900650, 856504729);
@@ -1065,7 +1065,7 @@ public static void uint4x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_bitwise_or_wide_scalar()
         {
             uint4x4 a0 = uint4x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676, 228656898, 41280811, 1536908787, 606786773);
@@ -1089,7 +1089,7 @@ public static void uint4x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1113,7 +1113,7 @@ public static void uint4x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_bitwise_xor_wide_wide()
         {
             uint4x4 a0 = uint4x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919, 26631152, 1016475570, 1862440929, 379588576);
@@ -1137,7 +1137,7 @@ public static void uint4x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_bitwise_xor_wide_scalar()
         {
             uint4x4 a0 = uint4x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786, 625604047, 1700827127, 2003392824, 1481813598);
@@ -1161,7 +1161,7 @@ public static void uint4x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1185,7 +1185,7 @@ public static void uint4x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_left_shift()
         {
             uint4x4 a0 = uint4x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902, 1959056531, 1779118882, 1451674188, 2082026915);
@@ -1209,7 +1209,7 @@ public static void uint4x4_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_right_shift()
         {
             uint4x4 a0 = uint4x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878, 667378673, 1611921244, 307750782, 479442287);
@@ -1233,7 +1233,7 @@ public static void uint4x4_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4x4_operator_bitwise_not()
         {
             uint4x4 a0 = uint4x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785, 916013379, 203444882, 1172294211, 1020232736);
@@ -1253,7 +1253,7 @@ public static void uint4x4_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCase]
+        [TestCase /* For player builds */]
         public static void uint4x4_EqualsObjectOverride()
         {
             TestUtils.IsFalse(new uint4x4().Equals((object)new int()));
diff --git a/src/Tests/Tests/TestMath2.cs b/src/Tests/Tests/TestMath2.cs
index 09e2d3a9..7bbac675 100644
--- a/src/Tests/Tests/TestMath2.cs
+++ b/src/Tests/Tests/TestMath2.cs
@@ -1,13 +1,14 @@
 using NUnit.Framework;
 using static Unity.Mathematics.math;
 using Burst.Compiler.IL.Tests;
+using System;
 
 namespace Unity.Mathematics.Tests
 {
     [TestFixture]
     public partial class TestMath
     {
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public unsafe void hash_blob()
         {
             byte[] testData = {
@@ -59,5 +60,71 @@ public unsafe void hash_blob()
                 }
             }
         }
+
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        public unsafe void hash_blob_unaligned()
+        {
+            byte[] testData = {
+                0x0d, 0x26, 0x1c, 0xeb, 0x56, 0x3a, 0x9c, 0x18, 0x93, 0xb6,
+                0xc1, 0x99, 0x5e, 0x04, 0x92, 0x4f, 0x6e, 0xb7, 0x42, 0x53,
+                0x23, 0xcf, 0xe3, 0xbf, 0x16, 0x64, 0x79, 0x08, 0xc1, 0x01,
+                0x43, 0x89, 0x73, 0x8f, 0x76, 0x22, 0x0c, 0xee, 0x9b, 0x80,
+                0x31, 0x83, 0xce, 0x33, 0x8b, 0xc7, 0x3f, 0x94, 0x33
+            };
+
+            uint[] resultsWithZeroSeed =
+            {
+                0x02cc5d05, 0x376a5b3f, 0x8ae13198, 0xf5b14d72, 0xcc7ddc84,
+                0x763e5905, 0x58759392, 0x6bccbd00, 0x7d0f80c8, 0xef01ae48,
+                0xe40aa3ad, 0x805e04ad, 0xf98a471c, 0xdd960ac1, 0x76a71750,
+                0xd35e2baa, 0x0219f7da, 0xd5bd1fbd, 0x5f28c87e, 0xfe6f7995,
+                0x69a43ac5, 0xec1a1a15, 0x7ae9f103, 0x8d04a688, 0xce3b35be,
+                0x6b3f040c, 0xd5ea2e8c, 0x6989e79c, 0x8772f1fb, 0x0d7b7bf6,
+                0x0796214b, 0x98ea65c4, 0x3884dd82, 0x59632484, 0x91c92822,
+                0x72d28404, 0x167061b0, 0x32adc2ef, 0xbac3e672, 0xd39936b7,
+                0x94e2c154, 0x8b4ff46c, 0x68976fd4, 0x04bee59a, 0x2ed62c69,
+                0xabee69fd, 0xda11e266, 0xcebd9d38, 0x28eea5fd, 0x0210d6ee
+            };
+
+
+            uint[] resultsWith_0xeb69cf40_seed =
+            {
+                0x12c3b280, 0x9bc1f68d, 0x2f900b51, 0xdb77e20e, 0xf6e8f561,
+                0x3f3f72f6, 0x15f9700f, 0x28beb671, 0xceece5e1, 0x7a9b5c81,
+                0x62a84642, 0xf75666af, 0x8939f8ca, 0x6b84792b, 0x527ee836,
+                0xa0782090, 0xce6b9926, 0xa608c73b, 0xa08ee6a3, 0xab77a6b2,
+                0x4e174e68, 0x596f10d5, 0xa14c4d85, 0x509ab88d, 0xd14698a4,
+                0xbaad2308, 0xbd04c3df, 0x5715fed1, 0x5cf23a74, 0xd4e844f9,
+                0x166dcfba, 0xe3495e37, 0x1b18b2b3, 0x2e8c2aab, 0x40993321,
+                0x4b84998a, 0xd062937d, 0x1b2c9f7b, 0x8a613ed3, 0x70d71291,
+                0x1af38ea4, 0x460cb7e9, 0xf806e3a9, 0xec9b6b2e, 0x9972a843,
+                0x1ff06d2a, 0xe8c5007b, 0x37d8fc40, 0x0dc4f639, 0x36edff4f
+            };
+
+            byte* buffer = stackalloc byte[testData.Length + 1];
+            fixed (byte* p = testData)
+            {
+                UIntPtr address = (UIntPtr)p;
+                bool isUnaligned = ((ulong)address & 1) > 0;
+                byte* unalignedPtr = buffer;
+
+                if (!isUnaligned)
+                {
+                    ++unalignedPtr;
+                }
+
+                Buffer.MemoryCopy(p, unalignedPtr, testData.Length + 1, testData.Length);
+
+                for (int i = 0; i < 50; ++i)
+                {
+                    TestUtils.AreEqual(hash(unalignedPtr, i, 0), resultsWithZeroSeed[i]);
+                }
+
+                for (int i = 0; i < 50; ++i)
+                {
+                    TestUtils.AreEqual(hash(unalignedPtr, i, 0xeb69cf40), resultsWith_0xeb69cf40_seed[i]);
+                }
+            }
+        }
     }
 }
diff --git a/src/Tests/Tests/TestRandom.cs b/src/Tests/Tests/TestRandom.cs
index 35bc9abd..9de2112b 100644
--- a/src/Tests/Tests/TestRandom.cs
+++ b/src/Tests/Tests/TestRandom.cs
@@ -115,14 +115,14 @@ private static double range_check(double x, double min, double max)
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => rnd.NextBool() ? 0.75 : 0.25), 2);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -130,14 +130,14 @@ public static void bool2_uniform()
             ks_test((() => rnd.NextBool2().y ? 0.75 : 0.25), 2);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool2_independent()
         {
             var rnd = new Random(0x6E624EB7u);
             r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool2().xy)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -146,7 +146,7 @@ public static void bool3_uniform()
             ks_test((() => rnd.NextBool3().z ? 0.75 : 0.25), 2);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool3_independent()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -155,7 +155,7 @@ public static void bool3_independent()
             r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool3().yz)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -165,7 +165,7 @@ public static void bool4_uniform()
             ks_test((() => rnd.NextBool4().w ? 0.75 : 0.25), 2);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void bool4_independent()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -177,21 +177,21 @@ public static void bool4_independent()
             r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool4().zw)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => ((rnd.NextInt() & 255u) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int_uniform_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => (((uint)rnd.NextInt() >> 24) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -199,7 +199,7 @@ public static void int_uniform_max()
             ks_test((() => (range_check(rnd.NextInt(max), 0, max) + 0.5) / max), max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int_uniform_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -207,7 +207,7 @@ public static void int_uniform_max_limit()
             ks_test((() => (range_check(rnd.NextInt(max), 0, max) + 0.5) / max), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -217,7 +217,7 @@ public static void int_uniform_min_max()
             ks_test((() => (range_check(rnd.NextInt(min, max), min, max) + 0.5 - min) / range), range);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int_uniform_min_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -227,7 +227,7 @@ public static void int_uniform_min_max_limit()
             ks_test((() => (range_check(rnd.NextInt(min, max), min, max) + 0.5 - min) / range), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -235,7 +235,7 @@ public static void int2_uniform_low_bits()
             ks_test((() => ((rnd.NextInt2().y & 255u) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_uniform_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -243,7 +243,7 @@ public static void int2_uniform_high_bits()
             ks_test((() => (((uint)rnd.NextInt2().y >> 24) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -252,7 +252,7 @@ public static void int2_uniform_max()
             ks_test((() => (range_check(rnd.NextInt2(max).y, 0, max) + 0.5) / max), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -263,7 +263,7 @@ public static void int2_uniform_min_max()
             ks_test((() => (range_check(rnd.NextInt2(min, max).y, min.y, max.y) + 0.5 - min.y) / range.y), range.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_uniform_min_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -274,21 +274,21 @@ public static void int2_uniform_min_max_limit()
             ks_test((() => (range_check(rnd.NextInt2(min, max).y, min, max) + 0.5 - min) / range), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_independent_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             r_test(() => (rnd.NextInt2().xy & 255));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int2_independent_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             r_test(() => ((uint2)rnd.NextInt2().xy >> 24));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -297,7 +297,7 @@ public static void int3_uniform_low_bits()
             ks_test((() => ((rnd.NextInt3().z & 255u) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_uniform_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -306,7 +306,7 @@ public static void int3_uniform_high_bits()
             ks_test((() => (((uint)rnd.NextInt3().z >> 24) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -316,7 +316,7 @@ public static void int3_uniform_max()
             ks_test((() => ((uint)range_check(rnd.NextInt3(max).z, 0, max.z) + 0.5) / max.z), max.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_uniform_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -326,7 +326,7 @@ public static void int3_uniform_max_limit()
             ks_test((() => ((uint)range_check(rnd.NextInt3(max).z, 0, max) + 0.5) / max), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -338,7 +338,7 @@ public static void int3_uniform_min_max()
             ks_test((() => (range_check(rnd.NextInt3(min, max).z, min.z, max.z) + 0.5 - min.z) / range.z), range.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_uniform_min_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -350,7 +350,7 @@ public static void int3_uniform_min_max_limit()
             ks_test((() => (range_check(rnd.NextInt3(min, max).z, min, max) + 0.5 - min) / range), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_independent_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -359,7 +359,7 @@ public static void int3_independent_low_bits()
             r_test(() => (rnd.NextInt3().yz & 255));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int3_independent_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -368,7 +368,7 @@ public static void int3_independent_high_bits()
             r_test(() => ((uint2)rnd.NextInt3().yz >> 24));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -378,7 +378,7 @@ public static void int4_uniform_low_bits()
             ks_test((() => ((rnd.NextInt4().w & 255u) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_uniform_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -388,7 +388,7 @@ public static void int4_uniform_high_bits()
             ks_test((() => (((uint)rnd.NextInt4().w >> 24) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -399,7 +399,7 @@ public static void int4_uniform_max()
             ks_test((() => (range_check(rnd.NextInt4(max).w, 0, max.w) + 0.5) / max.w), max.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_uniform_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -410,7 +410,7 @@ public static void int4_uniform_max_limit()
             ks_test((() => (range_check(rnd.NextInt4(max).w, 0, max) + 0.5) / max), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -423,7 +423,7 @@ public static void int4_uniform_min_max()
             ks_test((() => (range_check(rnd.NextInt4(min, max).w, min.w, max.w) + 0.5 - min.w) / range.w), range.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_uniform_min_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -436,7 +436,7 @@ public static void int4_uniform_min_max_limit()
             ks_test((() => (range_check(rnd.NextInt4(min, max).w, min, max) + 0.5 - min) / range), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_independent_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -448,7 +448,7 @@ public static void int4_independent_low_bits()
             r_test(() => (rnd.NextUInt4().zw & 255));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void int4_independent_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -461,21 +461,21 @@ public static void int4_independent_high_bits()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => ((rnd.NextUInt() & 255u) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint_uniform_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => ((rnd.NextUInt() >> 24) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -483,7 +483,7 @@ public static void uint_uniform_max()
             ks_test((() => (rnd.NextUInt(max) + 0.5) / max), (int)max);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint_uniform_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -491,7 +491,7 @@ public static void uint_uniform_max_limit()
             ks_test((() => (rnd.NextUInt(max) + 0.5) / max), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -501,7 +501,7 @@ public static void uint_uniform_min_max()
             ks_test((() => (range_check(rnd.NextUInt(min, max), min, max) + 0.5 - min) / range), (int)range);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint_uniform_min_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -509,7 +509,7 @@ public static void uint_uniform_min_max_limit()
             ks_test((() => (range_check(rnd.NextUInt(0, max), 0, max) + 0.5) / max), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -517,7 +517,7 @@ public static void uint2_uniform_low_bits()
             ks_test((() => ((rnd.NextUInt2().y & 255u) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_uniform_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -525,7 +525,7 @@ public static void uint2_uniform_high_bits()
             ks_test((() => ((rnd.NextUInt2().y >> 24) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -534,7 +534,7 @@ public static void uint2_uniform_max()
             ks_test((() => (rnd.NextUInt2(max).y + 0.5) / max.y), (int)max.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_uniform_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -543,7 +543,7 @@ public static void uint2_uniform_max_limit()
             ks_test((() => (rnd.NextUInt2(max).y + 0.5) / max), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -554,7 +554,7 @@ public static void uint2_uniform_min_max()
             ks_test((() => (range_check(rnd.NextUInt2(min, max).y, min.y, max.y) + 0.5 - min.y) / range.y), (int)range.y);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_uniform_min_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -563,21 +563,21 @@ public static void uint2_uniform_min_max_limit()
             ks_test((() => (range_check(rnd.NextUInt2(0, max).y, 0, max) + 0.5) / max), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_independent_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             r_test(() => (rnd.NextUInt2().xy & 255));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint2_independent_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             r_test(() => (rnd.NextUInt2().xy >> 24));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -586,7 +586,7 @@ public static void uint3_uniform_low_bits()
             ks_test((() => ((rnd.NextUInt3().z & 255u) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_uniform_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -595,7 +595,7 @@ public static void uint3_uniform_high_bits()
             ks_test((() => ((rnd.NextUInt3().z >> 24) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -605,7 +605,7 @@ public static void uint3_uniform_max()
             ks_test((() => (rnd.NextUInt3(max).z + 0.5) / max.z), (int)max.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_uniform_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -615,7 +615,7 @@ public static void uint3_uniform_max_limit()
             ks_test((() => (rnd.NextUInt3(max).z + 0.5) / max), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -627,7 +627,7 @@ public static void uint3_uniform_min_max()
             ks_test((() => (range_check(rnd.NextUInt3(min, max).z, min.z, max.z) + 0.5 - min.z) / range.z), (int)range.z);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_uniform_min_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -637,7 +637,7 @@ public static void uint3_uniform_min_max_limit()
             ks_test((() => (range_check(rnd.NextUInt3(0, max).z, 0, max) + 0.5) / max), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_independent_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -646,7 +646,7 @@ public static void uint3_independent_low_bits()
             r_test(() => (rnd.NextUInt3().yz & 255));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint3_independent_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -655,7 +655,7 @@ public static void uint3_independent_high_bits()
             r_test(() => (rnd.NextUInt3().yz >> 24));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -665,7 +665,7 @@ public static void uint4_uniform_low_bits()
             ks_test((() => ((rnd.NextUInt4().w & 255u) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_uniform_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -675,7 +675,7 @@ public static void uint4_uniform_high_bits()
             ks_test((() => ((rnd.NextUInt4().w >> 24) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -686,7 +686,7 @@ public static void uint4_uniform_max()
             ks_test((() => (rnd.NextUInt4(max).w + 0.5) / max.w), (int)max.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_uniform_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -697,7 +697,7 @@ public static void uint4_uniform_max_limit()
             ks_test((() => (rnd.NextUInt4(max).w + 0.5) / max), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -710,7 +710,7 @@ public static void uint4_uniform_min_max()
             ks_test((() => (range_check(rnd.NextUInt4(min, max).w, min.w, max.w) + 0.5 - min.w) / range.w), (int)range.w);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_uniform_min_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -721,7 +721,7 @@ public static void uint4_uniform_min_max_limit()
             ks_test((() => (range_check(rnd.NextUInt4(0, max).w, 0, max) + 0.5) / max), 256);
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_independent_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -733,7 +733,7 @@ public static void uint4_independent_low_bits()
             r_test(() => (rnd.NextUInt4().zw & 255));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void uint4_independent_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -745,21 +745,21 @@ public static void uint4_independent_high_bits()
             r_test(() => (rnd.NextUInt4().zw >> 24));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => range_check01(rnd.NextFloat())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => frac(rnd.NextFloat() * 65536.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -767,7 +767,7 @@ public static void float_uniform_max()
             ks_test((() => range_check(rnd.NextFloat(max), 0.0f, max) / max));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -777,7 +777,7 @@ public static void float_uniform_min_max()
             ks_test((() => (range_check(rnd.NextFloat(min, max), min, max) -min) / range));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -785,7 +785,7 @@ public static void float2_uniform()
             ks_test((() => range_check01(rnd.NextFloat2().y)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -793,7 +793,7 @@ public static void float2_uniform_low_bits()
             ks_test((() => frac(rnd.NextFloat2().y * 65536.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -802,7 +802,7 @@ public static void float2_uniform_max()
             ks_test((() => range_check(rnd.NextFloat2(max).y, 0.0f, max.y) / max.y));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -813,14 +813,14 @@ public static void float2_uniform_min_max()
             ks_test((() => (range_check(rnd.NextFloat2(min, max).y, min.y, max.y) - min.y) / range.y));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_independent()
         {
             var rnd = new Random(0x6E624EB7u);
             r_test((() => rnd.NextFloat2()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -829,7 +829,7 @@ public static void float3_uniform()
             ks_test((() => range_check01(rnd.NextFloat3().z)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -838,7 +838,7 @@ public static void float3_uniform_low_bits()
             ks_test((() => frac(rnd.NextFloat3().z * 65536.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -848,7 +848,7 @@ public static void float3_uniform_max()
             ks_test((() => range_check(rnd.NextFloat3(max).z, 0.0f, max.z) / max.z));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -860,7 +860,7 @@ public static void float3_uniform_min_max()
             ks_test((() => (range_check(rnd.NextFloat3(min, max).z, min.z, max.z) - min.z) / range.z));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_independent()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -869,7 +869,7 @@ public static void float3_independent()
             r_test((() => rnd.NextFloat3().yz));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -879,7 +879,7 @@ public static void float4_uniform()
             ks_test((() => range_check01(rnd.NextFloat4().w)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -889,7 +889,7 @@ public static void float4_uniform_low_bits()
             ks_test((() => frac(rnd.NextFloat4().w * 65536.0f)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -900,7 +900,7 @@ public static void float4_uniform_max()
             ks_test((() => range_check(rnd.NextFloat4(max).w, 0.0f, max.w) / max.w));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -913,7 +913,7 @@ public static void float4_uniform_min_max()
             ks_test((() => (range_check(rnd.NextFloat4(min, max).w, min.w, max.w) - min.w) / range.w));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float4_independent()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -925,21 +925,21 @@ public static void float4_independent()
             r_test((() => rnd.NextFloat4().zw));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => range_check01(rnd.NextDouble())));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => frac(rnd.NextDouble() * 35184372088832.0)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -947,7 +947,7 @@ public static void double_uniform_max()
             ks_test((() => range_check(rnd.NextDouble(max), 0.0, max) / max));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -957,7 +957,7 @@ public static void double_uniform_min_max()
             ks_test((() => (range_check(rnd.NextDouble(min, max), min, max) - min) / range));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -965,7 +965,7 @@ public static void double2_uniform()
             ks_test((() => range_check01(rnd.NextDouble2().y)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -973,7 +973,7 @@ public static void double2_uniform_low_bits()
             ks_test((() => frac(rnd.NextDouble2().y * 35184372088832.0)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -982,7 +982,7 @@ public static void double2_uniform_max()
             ks_test((() => range_check(rnd.NextDouble2(max).y, 0.0, max.y) / max.y));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -993,14 +993,14 @@ public static void double2_uniform_min_max()
             ks_test((() => (range_check(rnd.NextDouble2(min, max).y, min.y, max.y) - min.y) / range.y));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_independent()
         {
             var rnd = new Random(0x6E624EB7u);
             r_test((() => rnd.NextDouble2()));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1009,7 +1009,7 @@ public static void double3_uniform()
             ks_test((() => range_check01(rnd.NextDouble3().z)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1018,7 +1018,7 @@ public static void double3_uniform_low_bits()
             ks_test((() => frac(rnd.NextDouble3().z * 35184372088832.0)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1028,7 +1028,7 @@ public static void double3_uniform_max()
             ks_test((() => range_check(rnd.NextDouble3(max).z, 0.0, max.z) / max.z));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1041,7 +1041,7 @@ public static void double3_uniform_min_max()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_independent()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1050,7 +1050,7 @@ public static void double3_independent()
             r_test((() => rnd.NextDouble3().yz));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1060,7 +1060,7 @@ public static void double4_uniform()
             ks_test((() => range_check01(rnd.NextDouble4().w)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1070,7 +1070,7 @@ public static void double4_uniform_low_bits()
             ks_test((() => frac(rnd.NextDouble4().w * 35184372088832.0)));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1081,7 +1081,7 @@ public static void double4_uniform_max()
             ks_test((() => range_check(rnd.NextDouble4(max).w, 0.0, max.w) / max.w));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1094,7 +1094,7 @@ public static void double4_uniform_min_max()
             ks_test((() => (range_check(rnd.NextDouble4(min, max).w, min.w, max.w) - min.w) / range.w));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double4_independent()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1106,7 +1106,7 @@ public static void double4_independent()
             r_test((() => rnd.NextDouble4().zw));
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float2_direction()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1117,7 +1117,7 @@ public static void float2_direction()
             });
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double2_direction()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1129,7 +1129,7 @@ public static void double2_direction()
         }
 
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void float3_direction()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1145,7 +1145,7 @@ public static void float3_direction()
             });
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void double3_direction()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1161,7 +1161,7 @@ public static void double3_direction()
             });
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void quaternion_rotation()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1183,7 +1183,7 @@ public static void quaternion_rotation()
             });
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void consecutive_seeds_r_test()
         {
             // Check that drawing 1 number from many consecutive seeds has no correlation.
@@ -1195,7 +1195,7 @@ public static void consecutive_seeds_r_test()
             }
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void consecutive_seeds_r_test2()
         {
             // Check that drawing 1 number from many consecutive seeds has no correlation.
@@ -1207,7 +1207,7 @@ public static void consecutive_seeds_r_test2()
             }
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void consecutive_seeds_ks_test()
         {
             // Check that drawing 1 number from many consecutive seeds matches our expected distribution.
@@ -1215,7 +1215,7 @@ public static void consecutive_seeds_ks_test()
             ks_test(() => Random.CreateFromIndex(seed++).NextDouble());
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void consecutive_seeds_ks_test2()
         {
             // Check that drawing 1 number from many consecutive seeds matches our expected distribution.
@@ -1223,7 +1223,7 @@ public static void consecutive_seeds_ks_test2()
             ks_test(() => Random.CreateFromIndex(seed++).NextDouble());
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void similar_seeds()
         {
             // Check to see that two consecutive seeds have no correlation when drawing
@@ -1236,7 +1236,7 @@ public static void similar_seeds()
             }
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void similar_seeds2()
         {
             // Check to see that two consecutive seeds have no correlation when drawing
@@ -1249,7 +1249,7 @@ public static void similar_seeds2()
             }
         }
 
-        [TestCompiler]
+        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
         public static void wang_hash()
         {
             TestUtils.AreEqual(3232319850u, Random.WangHash(0u));
diff --git a/src/Tests/Unity.Mathematics.Tests.asmdef b/src/Tests/Unity.Mathematics.Tests.asmdef
index 6b374c8a..29a41728 100644
--- a/src/Tests/Unity.Mathematics.Tests.asmdef
+++ b/src/Tests/Unity.Mathematics.Tests.asmdef
@@ -1,13 +1,21 @@
 {
     "name": "Unity.Mathematics.Tests",
-    "optionalUnityReferences": [
-        "TestAssemblies"
-    ],
+    "rootNamespace": "",
     "references": [
-        "Unity.Mathematics"
+        "Unity.Mathematics",
+        "UnityEngine.TestRunner"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": true,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
     ],
-    "includePlatforms": [
-        "Editor"
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
     ],
-    "allowUnsafeCode": true
-}
+    "versionDefines": [],
+    "noEngineReferences": false
+}
\ No newline at end of file
diff --git a/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs b/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs
index a6c203b3..778b2c25 100644
--- a/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs
+++ b/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs
@@ -2075,11 +2075,11 @@ private void BeginTest(StringBuilder str, string name, bool testCompiler = true)
         {
             if (testCompiler)
             {
-                str.Append("\t\t[TestCompiler]\n");
+                str.Append("\t\t[TestCompiler /* For Burst testing */, TestCase /* For player builds */]\n");
             }
             else
             {
-                str.Append("\t\t[TestCase]\n");
+                str.Append("\t\t[TestCase /* For player builds */]\n");
             }
 
             str.AppendFormat("\t\tpublic static void {0}()\n", name);
diff --git a/src/Unity.Mathematics.PerformanceTests/TestHash.cs b/src/Unity.Mathematics.PerformanceTests/TestHash.cs
new file mode 100644
index 00000000..106f451f
--- /dev/null
+++ b/src/Unity.Mathematics.PerformanceTests/TestHash.cs
@@ -0,0 +1,58 @@
+using Unity.Burst;
+using Unity.PerformanceTesting;
+using NUnit.Framework;
+using Unity.Collections.LowLevel.Unsafe;
+using System;
+using UnityEngine;
+
+namespace Unity.Mathematics.PerformanceTests
+{
+    [BurstCompile]
+    partial class TestHash
+    {
+        static readonly long kBufferBytes = 1024 * 1024;
+        static readonly long kBytesToHash = kBufferBytes - 1;
+        static readonly uint kExpectedHash = 1781740882;
+
+        [Test, Performance]
+        public static unsafe void HashAligned()
+        {
+            Assert.AreEqual(kExpectedHash, Hash(false));
+        }
+
+        [Test, Performance]
+        public static unsafe void HashUnaligned()
+        {
+            Assert.AreEqual(kExpectedHash, Hash(true));
+        }
+
+        [BurstCompile(CompileSynchronously = true)]
+        static unsafe uint Hash(bool useUnalignedBuffer)
+        {
+            var ptr = (ulong)(UIntPtr)UnsafeUtility.Malloc(kBufferBytes, 16, Collections.Allocator.Persistent);
+            var ulongptr = (ulong)ptr;
+            uint seed = 0;
+
+            if (useUnalignedBuffer && ((ulongptr & 1) == 0))
+            {
+                ++ulongptr;
+            }
+
+            var buffer = (void*)ulongptr;
+
+            for (int i = 0; i < kBytesToHash; ++i)
+            {
+                ((byte*)buffer)[i] = 123;
+            }
+
+            for (int i = 0; i < 100; ++i)
+            {
+                seed = math.hash(buffer, (int)kBytesToHash, seed);
+            }
+
+            UnsafeUtility.Free((void*)ptr, Collections.Allocator.Persistent);
+
+            return seed;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Unity.Mathematics.PerformanceTests/TestHash.cs.meta b/src/Unity.Mathematics.PerformanceTests/TestHash.cs.meta
new file mode 100644
index 00000000..fcfb809b
--- /dev/null
+++ b/src/Unity.Mathematics.PerformanceTests/TestHash.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c1a8761ebc1ffa240aa484721a63ba9f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/src/Unity.Mathematics.sln b/src/Unity.Mathematics.sln
index a0ea6974..ffeba31e 100644
--- a/src/Unity.Mathematics.sln
+++ b/src/Unity.Mathematics.sln
@@ -52,8 +52,16 @@ Global
 		{2E7C74D3-42F1-482F-8BB7-E199D9E3B412}.Release|x86.Build.0 = Release|Any CPU
 		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|x64.Build.0 = Debug|Any CPU
+		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Debug|x86.Build.0 = Debug|Any CPU
 		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|x64.ActiveCfg = Release|Any CPU
+		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|x64.Build.0 = Release|Any CPU
+		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|x86.ActiveCfg = Release|Any CPU
+		{293EBCD6-CACD-4DA8-A518-FBC629268C0F}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/src/Unity.Mathematics/math.cs b/src/Unity.Mathematics/math.cs
index 26b0d378..a1b4800d 100644
--- a/src/Unity.Mathematics/math.cs
+++ b/src/Unity.Mathematics/math.cs
@@ -6704,12 +6704,19 @@ public static float4 chgsign(float4 x, float4 y)
             return asfloat(asuint(x) ^ (asuint(y) & 0x80000000));
         }
 
-        /// <summary>Returns a uint hash from a block of memory using the xxhash32 algorithm. Can only be used in an unsafe context.</summary>
-        /// <param name="pBuffer">A pointer to the beginning of the data.</param>
-        /// <param name="numBytes">Number of bytes to hash.</param>
-        /// <param name="seed">Starting seed value.</param>
-        /// <returns>The 32 bit hash of the input data buffer.</returns>
-        public static unsafe uint hash(void* pBuffer, int numBytes, uint seed = 0)
+        /// <summary>
+        /// Read 32 bits of data in little endian format.
+        /// </summary>
+        /// <param name="pBuffer">Memory address to read from.</param>
+        /// <returns>32 bits in little endian format.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static unsafe uint read32_little_endian(void* pBuffer)
+        {
+            byte* ptr = (byte*)pBuffer;
+            return (uint)ptr[0] | ((uint)ptr[1] << 8) | ((uint)ptr[2] << 16) | ((uint)ptr[3] << 24);
+        }
+
+        private static unsafe uint hash_with_unaligned_loads(void* pBuffer, int numBytes, uint seed)
         {
             unchecked
             {
@@ -6762,6 +6769,74 @@ public static unsafe uint hash(void* pBuffer, int numBytes, uint seed = 0)
             }
         }
 
+        private static unsafe uint hash_without_unaligned_loads(void* pBuffer, int numBytes, uint seed)
+        {
+            unchecked
+            {
+                const uint Prime1 = 2654435761;
+                const uint Prime2 = 2246822519;
+                const uint Prime3 = 3266489917;
+                const uint Prime4 = 668265263;
+                const uint Prime5 = 374761393;
+
+                byte* p = (byte*)pBuffer;
+                uint hash = seed + Prime5;
+                if (numBytes >= 16)
+                {
+                    uint4 state = new uint4(Prime1 + Prime2, Prime2, 0, (uint)-Prime1) + seed;
+
+                    int count = numBytes >> 4;
+                    for (int i = 0; i < count; ++i)
+                    {
+                        var data = new uint4(read32_little_endian(p), read32_little_endian(p + 4), read32_little_endian(p + 8), read32_little_endian(p + 12));
+                        state += data * Prime2;
+                        state = rol(state, 13);
+                        state *= Prime1;
+                        p += 16;
+                    }
+
+                    hash = rol(state.x, 1) + rol(state.y, 7) + rol(state.z, 12) + rol(state.w, 18);
+                }
+
+                hash += (uint)numBytes;
+
+                for (int i = 0; i < ((numBytes >> 2) & 3); ++i)
+                {
+                    hash += read32_little_endian(p) * Prime3;
+                    hash = rol(hash, 17) * Prime4;
+                    p += 4;
+                }
+
+                for (int i = 0; i < ((numBytes) & 3); ++i)
+                {
+                    hash += (*p++) * Prime5;
+                    hash = rol(hash, 11) * Prime1;
+                }
+
+                hash ^= hash >> 15;
+                hash *= Prime2;
+                hash ^= hash >> 13;
+                hash *= Prime3;
+                hash ^= hash >> 16;
+
+                return hash;
+            }
+        }
+
+        /// <summary>Returns a uint hash from a block of memory using the xxhash32 algorithm. Can only be used in an unsafe context.</summary>
+        /// <param name="pBuffer">A pointer to the beginning of the data.</param>
+        /// <param name="numBytes">Number of bytes to hash.</param>
+        /// <param name="seed">Starting seed value.</param>
+        /// <returns>The 32 bit hash of the input data buffer.</returns>
+        public static unsafe uint hash(void* pBuffer, int numBytes, uint seed = 0)
+        {
+#if !UNITY_64 && UNITY_ANDROID
+            return hash_without_unaligned_loads(pBuffer, numBytes, seed);
+#else
+            return hash_with_unaligned_loads(pBuffer, numBytes, seed);
+#endif
+        }
+
         /// <summary>
         /// Unity's up axis (0, 1, 0).
         /// </summary>

From 970e2eda7ed5a05ed87dc909c09c742ea370e6a9 Mon Sep 17 00:00:00 2001
From: Kevin MacAulay Vacheresse <kevinmv@unity3d.com>
Date: Fri, 20 Oct 2023 11:12:15 -0230
Subject: [PATCH 67/94] Adds [Obsolete] tag to prevent warnings about
 implementing obsolete methods from the parent type avoiding CS0672. Warns
 users to not use these methods

---
 src/Unity.Mathematics.Editor/MatrixDrawer.cs          | 3 ++-
 src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/Unity.Mathematics.Editor/MatrixDrawer.cs b/src/Unity.Mathematics.Editor/MatrixDrawer.cs
index 3f31a0c7..00b4a4ff 100644
--- a/src/Unity.Mathematics.Editor/MatrixDrawer.cs
+++ b/src/Unity.Mathematics.Editor/MatrixDrawer.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using UnityEditor;
@@ -23,6 +23,7 @@ namespace Unity.Mathematics.Editor
     [CustomPropertyDrawer(typeof(uint4x2)), CustomPropertyDrawer(typeof(uint4x3)), CustomPropertyDrawer(typeof(uint4x4))]
     class MatrixDrawer : PropertyDrawer
     {
+        [Obsolete("CanCacheInspectorGUI has been deprecated, is no longer used and will be removed in later versions.", false)]
         public override bool CanCacheInspectorGUI(SerializedProperty property)
         {
             return false;
diff --git a/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs b/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs
index 28d8f47f..f7c7dbff 100644
--- a/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs
+++ b/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using UnityEditor;
 using UnityEngine;
 
@@ -44,6 +44,7 @@ static class Content
             public static readonly GUIContent[] labels4 = { new GUIContent("X"), new GUIContent("Y"), new GUIContent("Z"), new GUIContent("W") };
         }
 
+        [Obsolete("CanCacheInspectorGUI has been deprecated, is no longer used and will be removed in later versions.", false)]
         public override bool CanCacheInspectorGUI(SerializedProperty property)
         {
             return false;

From cefc6827bb7d496180d97e125841b479c1740f55 Mon Sep 17 00:00:00 2001
From: Kevin MacAulay Vacheresse <kevinmv@unity3d.com>
Date: Fri, 20 Oct 2023 11:15:42 -0230
Subject: [PATCH 68/94] Update changelog

---
 src/CHANGELOG.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index 2055eee9..aee5185a 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -1,10 +1,10 @@
 # Changelog
 
 ## [Unreleased]
-### Added
-### Changed
+
 ### Deprecated
-### Removed
+* `MatrixDrawer.CanCacheInspectorGUI` and `PrimitiveVectorDrawer.CanCacheInspectorGUI` are now marked as `[Obsolete]`. These methods never did anything, and still do not. They will be removed in a future release.
+
 ### Fixed
 * Fixed `math.hash` crash when using IL2CPP builds on Arm 32 bit devices.
 

From 4c2b8ff74724bf8a24776acdcc5cccbf3751ea32 Mon Sep 17 00:00:00 2001
From: Kevin MacAulay Vacheresse <kevinmv@unity3d.com>
Date: Fri, 20 Oct 2023 12:14:46 -0230
Subject: [PATCH 69/94] Cleanup changes to remove the obsolete methods in
 UNITY_2023_2_OR_NEWER outright

---
 src/CHANGELOG.md                                      | 4 +---
 src/Unity.Mathematics.Editor/MatrixDrawer.cs          | 3 ++-
 src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs | 3 ++-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index aee5185a..f51a25d0 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -2,11 +2,9 @@
 
 ## [Unreleased]
 
-### Deprecated
-* `MatrixDrawer.CanCacheInspectorGUI` and `PrimitiveVectorDrawer.CanCacheInspectorGUI` are now marked as `[Obsolete]`. These methods never did anything, and still do not. They will be removed in a future release.
-
 ### Fixed
 * Fixed `math.hash` crash when using IL2CPP builds on Arm 32 bit devices.
+* Fixed obsolete method usage warnings for `MatrixDrawer.CanCacheInspectorGUI` and `PrimitiveVectorDrawer.CanCacheInspectorGUI` in UNITY_2023_2_OR_NEWER.
 
 ## [1.3.1] - 2023-07-12
 
diff --git a/src/Unity.Mathematics.Editor/MatrixDrawer.cs b/src/Unity.Mathematics.Editor/MatrixDrawer.cs
index 00b4a4ff..f59d2c91 100644
--- a/src/Unity.Mathematics.Editor/MatrixDrawer.cs
+++ b/src/Unity.Mathematics.Editor/MatrixDrawer.cs
@@ -23,11 +23,12 @@ namespace Unity.Mathematics.Editor
     [CustomPropertyDrawer(typeof(uint4x2)), CustomPropertyDrawer(typeof(uint4x3)), CustomPropertyDrawer(typeof(uint4x4))]
     class MatrixDrawer : PropertyDrawer
     {
-        [Obsolete("CanCacheInspectorGUI has been deprecated, is no longer used and will be removed in later versions.", false)]
+#if !UNITY_2023_2_OR_NEWER
         public override bool CanCacheInspectorGUI(SerializedProperty property)
         {
             return false;
         }
+#endif
 
         public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
         {
diff --git a/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs b/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs
index f7c7dbff..cde01f38 100644
--- a/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs
+++ b/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs
@@ -44,11 +44,12 @@ static class Content
             public static readonly GUIContent[] labels4 = { new GUIContent("X"), new GUIContent("Y"), new GUIContent("Z"), new GUIContent("W") };
         }
 
-        [Obsolete("CanCacheInspectorGUI has been deprecated, is no longer used and will be removed in later versions.", false)]
+#if !UNITY_2023_2_OR_NEWER
         public override bool CanCacheInspectorGUI(SerializedProperty property)
         {
             return false;
         }
+#endif
 
         public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
         {

From bf1c2c51725f6b69de6509595f2b7d491e0c3782 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Thu, 30 Nov 2023 19:34:20 -0800
Subject: [PATCH 70/94] Fix project?

---
 .../Unity.Mathematics.csproj                  | 89 -------------------
 1 file changed, 89 deletions(-)

diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj
index 296381f2..9ecf8cea 100644
--- a/src/Unity.Mathematics/Unity.Mathematics.csproj
+++ b/src/Unity.Mathematics/Unity.Mathematics.csproj
@@ -13,95 +13,6 @@
     <Compile Remove="PropertyAttributes.cs" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="affine_transform.cs" />
-    <Compile Include="bool2.gen.cs" />
-    <Compile Include="bool2x2.gen.cs" />
-    <Compile Include="bool2x3.gen.cs" />
-    <Compile Include="bool2x4.gen.cs" />
-    <Compile Include="bool3.gen.cs" />
-    <Compile Include="bool3x2.gen.cs" />
-    <Compile Include="bool3x3.gen.cs" />
-    <Compile Include="bool3x4.gen.cs" />
-    <Compile Include="bool4.gen.cs" />
-    <Compile Include="bool4x2.gen.cs" />
-    <Compile Include="bool4x3.gen.cs" />
-    <Compile Include="bool4x4.gen.cs" />
-    <Compile Include="double2.gen.cs" />
-    <Compile Include="double2x2.gen.cs" />
-    <Compile Include="double2x3.gen.cs" />
-    <Compile Include="double2x4.gen.cs" />
-    <Compile Include="double3.gen.cs" />
-    <Compile Include="double3x2.gen.cs" />
-    <Compile Include="double3x3.gen.cs" />
-    <Compile Include="double3x4.gen.cs" />
-    <Compile Include="double4.gen.cs" />
-    <Compile Include="double4x2.gen.cs" />
-    <Compile Include="double4x3.gen.cs" />
-    <Compile Include="double4x4.gen.cs" />
-    <Compile Include="Geometry\MinMaxAABB.cs" />
-    <Compile Include="Geometry\Plane.cs" />
-    <Compile Include="float2.gen.cs" />
-    <Compile Include="float2x2.gen.cs" />
-    <Compile Include="float2x3.gen.cs" />
-    <Compile Include="float2x4.gen.cs" />
-    <Compile Include="float3.gen.cs" />
-    <Compile Include="float3x2.gen.cs" />
-    <Compile Include="float3x3.gen.cs" />
-    <Compile Include="float3x4.gen.cs" />
-    <Compile Include="float4.gen.cs" />
-    <Compile Include="float4x2.gen.cs" />
-    <Compile Include="float4x3.gen.cs" />
-    <Compile Include="float4x4.gen.cs" />
-    <Compile Include="half.cs" />
-    <Compile Include="half2.gen.cs" />
-    <Compile Include="half3.gen.cs" />
-    <Compile Include="half4.gen.cs" />
-    <Compile Include="Il2CppEagerStaticClassConstructionAttribute.cs" />
-    <Compile Include="int2x2.gen.cs" />
-    <Compile Include="int2x3.gen.cs" />
-    <Compile Include="int2x4.gen.cs" />
-    <Compile Include="int3x2.gen.cs" />
-    <Compile Include="int3x3.gen.cs" />
-    <Compile Include="int3x4.gen.cs" />
-    <Compile Include="int4x2.gen.cs" />
-    <Compile Include="int4x3.gen.cs" />
-    <Compile Include="int4x4.gen.cs" />
-    <Compile Include="math.cs" />
-    <Compile Include="int2.gen.cs" />
-    <Compile Include="int3.gen.cs" />
-    <Compile Include="int4.gen.cs" />
-    <Compile Include="matrix.cs" />
-    <Compile Include="matrix.gen.cs" />
-    <Compile Include="Noise\cellular2D.cs" />
-    <Compile Include="Noise\cellular2x2.cs" />
-    <Compile Include="Noise\cellular2x2x2.cs" />
-    <Compile Include="Noise\cellular3D.cs" />
-    <Compile Include="Noise\classicnoise2D.cs" />
-    <Compile Include="Noise\classicnoise3D.cs" />
-    <Compile Include="Noise\classicnoise4D.cs" />
-    <Compile Include="Noise\common.cs" />
-    <Compile Include="Noise\noise2D.cs" />
-    <Compile Include="Noise\noise3D.cs" />
-    <Compile Include="Noise\noise3Dgrad.cs" />
-    <Compile Include="Noise\noise4D.cs" />
-    <Compile Include="Noise\psrdnoise2D.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="quaternion.cs" />
-    <Compile Include="rigid_transform.cs" />
-    <Compile Include="random.cs" />
-    <Compile Include="svd.cs" />
-    <Compile Include="uint2.gen.cs" />
-    <Compile Include="uint2x2.gen.cs" />
-    <Compile Include="uint2x3.gen.cs" />
-    <Compile Include="uint2x4.gen.cs" />
-    <Compile Include="uint3.gen.cs" />
-    <Compile Include="uint3x2.gen.cs" />
-    <Compile Include="uint3x3.gen.cs" />
-    <Compile Include="uint3x4.gen.cs" />
-    <Compile Include="uint4.gen.cs" />
-    <Compile Include="uint4x2.gen.cs" />
-    <Compile Include="uint4x3.gen.cs" />
-    <Compile Include="uint4x4.gen.cs" />
     <!-- Allows targeting net471 on non-Windows platforms -->
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
   </ItemGroup>

From 3ce550cdfc793de130419303137820ee48f718ab Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Mon, 4 Dec 2023 15:21:43 -0800
Subject: [PATCH 71/94] Revert "recover burst compatibility"

This reverts commit 6c978302ee98bcebadc69a9e8ddb039a8a33f70c.
---
 .../Properties/AssemblyInfo.cs                | 47 +++++++++++++++++++
 .../Unity.Mathematics.csproj                  | 38 ++++++++++++---
 2 files changed, 79 insertions(+), 6 deletions(-)
 create mode 100644 src/Unity.Mathematics/Properties/AssemblyInfo.cs

diff --git a/src/Unity.Mathematics/Properties/AssemblyInfo.cs b/src/Unity.Mathematics/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..c090f5b4
--- /dev/null
+++ b/src/Unity.Mathematics/Properties/AssemblyInfo.cs
@@ -0,0 +1,47 @@
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+#if !UNITY_DOTSPLAYER
+using System.Reflection;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+
+[assembly: AssemblyTitle("Unity.Mathematics")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Unity.Mathematics")]
+[assembly: AssemblyCopyright("Copyright ©  2017")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+
+[assembly: Guid("19810344-7387-4155-935F-BDD5CC61F0BF")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
+#endif
+
+[assembly: InternalsVisibleTo("Unity.Mathematics.Tests")]
+[assembly: InternalsVisibleTo("Unity.Mathematics.PerformanceTests")]
+[assembly: InternalsVisibleTo("btests")]
\ No newline at end of file
diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj
index 9ecf8cea..a6d2d9d4 100644
--- a/src/Unity.Mathematics/Unity.Mathematics.csproj
+++ b/src/Unity.Mathematics/Unity.Mathematics.csproj
@@ -1,7 +1,27 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
-    <TargetFramework>net471</TargetFramework>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{19810344-7387-4155-935F-BDD5CC61F0BF}</ProjectGuid>
+    <ProjectTypeGuids>{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Unity</RootNamespace>
+    <AssemblyName>Unity.Mathematics</AssemblyName>
+    <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\build\bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
     <OutputPath>..\..\build\bin\$(Configuration)\</OutputPath>
@@ -9,12 +29,18 @@
     <Version>1.0.0.0</Version> 
   </PropertyGroup>
   <ItemGroup>
-    <Compile Remove="math_unity_conversion.cs" />
-    <Compile Remove="PropertyAttributes.cs" />
+    <Reference Include="System" />
   </ItemGroup>
   <ItemGroup>
     <!-- Allows targeting net471 on non-Windows platforms -->
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
   </ItemGroup>
-  <ItemGroup />
-</Project>
\ No newline at end of file
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

From 539d4ef8c78bd9c3eafa50d5f414416e15be385b Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Tue, 5 Dec 2023 11:31:47 -0800
Subject: [PATCH 72/94] Revert "Revert "recover burst compatibility""

This reverts commit 3ce550cdfc793de130419303137820ee48f718ab.
---
 .../Properties/AssemblyInfo.cs                | 47 -------------------
 .../Unity.Mathematics.csproj                  | 38 +++------------
 2 files changed, 6 insertions(+), 79 deletions(-)
 delete mode 100644 src/Unity.Mathematics/Properties/AssemblyInfo.cs

diff --git a/src/Unity.Mathematics/Properties/AssemblyInfo.cs b/src/Unity.Mathematics/Properties/AssemblyInfo.cs
deleted file mode 100644
index c090f5b4..00000000
--- a/src/Unity.Mathematics/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-#if !UNITY_DOTSPLAYER
-using System.Reflection;
-
-// General Information about an assembly is controlled through the following
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-
-[assembly: AssemblyTitle("Unity.Mathematics")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("Unity.Mathematics")]
-[assembly: AssemblyCopyright("Copyright ©  2017")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Setting ComVisible to false makes the types in this assembly not visible
-// to COM components.  If you need to access a type in this assembly from
-// COM, set the ComVisible attribute to true on that type.
-
-[assembly: ComVisible(false)]
-
-// The following GUID is for the ID of the typelib if this project is exposed to COM
-
-[assembly: Guid("19810344-7387-4155-935F-BDD5CC61F0BF")]
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
-#endif
-
-[assembly: InternalsVisibleTo("Unity.Mathematics.Tests")]
-[assembly: InternalsVisibleTo("Unity.Mathematics.PerformanceTests")]
-[assembly: InternalsVisibleTo("btests")]
\ No newline at end of file
diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj
index a6d2d9d4..9ecf8cea 100644
--- a/src/Unity.Mathematics/Unity.Mathematics.csproj
+++ b/src/Unity.Mathematics/Unity.Mathematics.csproj
@@ -1,27 +1,7 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{19810344-7387-4155-935F-BDD5CC61F0BF}</ProjectGuid>
-    <ProjectTypeGuids>{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>Unity</RootNamespace>
-    <AssemblyName>Unity.Mathematics</AssemblyName>
-    <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <TargetFramework>net471</TargetFramework>
     <PlatformTarget>AnyCPU</PlatformTarget>
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>..\..\build\bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
     <OutputPath>..\..\build\bin\$(Configuration)\</OutputPath>
@@ -29,18 +9,12 @@
     <Version>1.0.0.0</Version> 
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="System" />
+    <Compile Remove="math_unity_conversion.cs" />
+    <Compile Remove="PropertyAttributes.cs" />
   </ItemGroup>
   <ItemGroup>
     <!-- Allows targeting net471 on non-Windows platforms -->
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
   </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
-</Project>
+  <ItemGroup />
+</Project>
\ No newline at end of file

From 2ef61553306c3efd9a341479e4a7e354b1159e7f Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Tue, 5 Dec 2023 11:45:27 -0800
Subject: [PATCH 73/94] Make internals visible to mathematics tests.

---
 src/Tests/Unity.Mathematics.Tests.csproj       | 4 ++--
 src/Unity.Mathematics/Geometry/MinMaxAABB.cs   | 4 ++--
 src/Unity.Mathematics/Geometry/Plane.cs        | 2 +-
 src/Unity.Mathematics/Unity.Mathematics.csproj | 1 +
 4 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/Tests/Unity.Mathematics.Tests.csproj b/src/Tests/Unity.Mathematics.Tests.csproj
index 691f7fb0..db3c9463 100644
--- a/src/Tests/Unity.Mathematics.Tests.csproj
+++ b/src/Tests/Unity.Mathematics.Tests.csproj
@@ -105,7 +105,7 @@
     <Compile Include="Tests\Shared\TestMath.gen.cs" />
     <Compile Include="Tests\Shared\TestMatrix.cs" />
     <Compile Include="Tests\Shared\TestMinMaxAABB.cs" />
-    <Compile Include="Tests\Shared\TestPlane.cs" / >
+    <Compile Include="Tests\Shared\TestPlane.cs" />
     <Compile Include="Tests\Shared\TestQuaternion.cs" />
     <Compile Include="Tests\Shared\TestRigidTransform.cs" />
     <Compile Include="Tests\Shared\TestSvd.cs" />
@@ -145,4 +145,4 @@
   <Target Name="AfterBuild">
   </Target>
   -->
-</Project>
\ No newline at end of file
+</Project>
diff --git a/src/Unity.Mathematics/Geometry/MinMaxAABB.cs b/src/Unity.Mathematics/Geometry/MinMaxAABB.cs
index 6b5b666d..eb4a3876 100644
--- a/src/Unity.Mathematics/Geometry/MinMaxAABB.cs
+++ b/src/Unity.Mathematics/Geometry/MinMaxAABB.cs
@@ -16,7 +16,7 @@ namespace Unity.Mathematics.Geometry
     /// </remarks>
     [System.Serializable]
     [Il2CppEagerStaticClassConstruction]
-    public struct MinMaxAABB : IEquatable<MinMaxAABB>
+    internal struct MinMaxAABB : IEquatable<MinMaxAABB>
     {
         /// <summary>
         /// The minimum point contained by the AABB.
@@ -213,7 +213,7 @@ public override string ToString()
         }
     }
 
-    public static partial class Math
+    internal static partial class Math
     {
         /// <summary>
         /// Transforms the AABB with the given transform.
diff --git a/src/Unity.Mathematics/Geometry/Plane.cs b/src/Unity.Mathematics/Geometry/Plane.cs
index 5094bb94..92d47c5e 100644
--- a/src/Unity.Mathematics/Geometry/Plane.cs
+++ b/src/Unity.Mathematics/Geometry/Plane.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Geometry
     [DebuggerDisplay("{Normal}, {Distance}")]
     [Serializable]
     [Il2CppEagerStaticClassConstruction]
-    public struct Plane
+    internal struct Plane
     {
         /// <summary>
         /// A plane in the form Ax + By + Cz + Dw = 0.
diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj
index 9ecf8cea..6a97724f 100644
--- a/src/Unity.Mathematics/Unity.Mathematics.csproj
+++ b/src/Unity.Mathematics/Unity.Mathematics.csproj
@@ -15,6 +15,7 @@
   <ItemGroup>
     <!-- Allows targeting net471 on non-Windows platforms -->
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
+    <InternalsVisibleTo Include="Unity.Mathematics.Tests" />
   </ItemGroup>
   <ItemGroup />
 </Project>
\ No newline at end of file

From bb2234d71933cf6fbd66807a264331881ffb0f72 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Tue, 5 Dec 2023 12:02:20 -0800
Subject: [PATCH 74/94] Make Geometry stuff public again for burst.

---
 src/Unity.Mathematics/Geometry/MinMaxAABB.cs | 4 ++--
 src/Unity.Mathematics/Geometry/Plane.cs      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Unity.Mathematics/Geometry/MinMaxAABB.cs b/src/Unity.Mathematics/Geometry/MinMaxAABB.cs
index eb4a3876..6b5b666d 100644
--- a/src/Unity.Mathematics/Geometry/MinMaxAABB.cs
+++ b/src/Unity.Mathematics/Geometry/MinMaxAABB.cs
@@ -16,7 +16,7 @@ namespace Unity.Mathematics.Geometry
     /// </remarks>
     [System.Serializable]
     [Il2CppEagerStaticClassConstruction]
-    internal struct MinMaxAABB : IEquatable<MinMaxAABB>
+    public struct MinMaxAABB : IEquatable<MinMaxAABB>
     {
         /// <summary>
         /// The minimum point contained by the AABB.
@@ -213,7 +213,7 @@ public override string ToString()
         }
     }
 
-    internal static partial class Math
+    public static partial class Math
     {
         /// <summary>
         /// Transforms the AABB with the given transform.
diff --git a/src/Unity.Mathematics/Geometry/Plane.cs b/src/Unity.Mathematics/Geometry/Plane.cs
index 92d47c5e..5094bb94 100644
--- a/src/Unity.Mathematics/Geometry/Plane.cs
+++ b/src/Unity.Mathematics/Geometry/Plane.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Geometry
     [DebuggerDisplay("{Normal}, {Distance}")]
     [Serializable]
     [Il2CppEagerStaticClassConstruction]
-    internal struct Plane
+    public struct Plane
     {
         /// <summary>
         /// A plane in the form Ax + By + Cz + Dw = 0.

From c1cffbda9db093e030fee5e745f4161ee1675537 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Tue, 5 Dec 2023 12:14:26 -0800
Subject: [PATCH 75/94] Make svd public for burst testing.

---
 src/Unity.Mathematics/svd.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Unity.Mathematics/svd.cs b/src/Unity.Mathematics/svd.cs
index b0a32112..fa50b669 100644
--- a/src/Unity.Mathematics/svd.cs
+++ b/src/Unity.Mathematics/svd.cs
@@ -7,7 +7,7 @@ namespace Unity.Mathematics
     // Computing the singular value decomposition of 3x3 matrices with minimal branching and elementary floating point operations,
     // A.McAdams, A.Selle, R.Tamstorf, J.Teran and E.Sifakis, University of Wisconsin - Madison technical report TR1690, May 2011
     [Il2CppEagerStaticClassConstruction]
-    static class svd
+    static public class svd
     {
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         static void condSwap(bool c, ref float x, ref float y)

From 8d574b191ec7a9e482bf81f3053b61f3565a0fc8 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Tue, 5 Dec 2023 12:32:17 -0800
Subject: [PATCH 76/94] Make internals visible to burst.

---
 src/Unity.Mathematics/Unity.Mathematics.csproj | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj
index 6a97724f..a87b134b 100644
--- a/src/Unity.Mathematics/Unity.Mathematics.csproj
+++ b/src/Unity.Mathematics/Unity.Mathematics.csproj
@@ -16,6 +16,8 @@
     <!-- Allows targeting net471 on non-Windows platforms -->
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
     <InternalsVisibleTo Include="Unity.Mathematics.Tests" />
+    <InternalsVisibleTo Include="Burst.Compiler.IL.Tests" />
+    <InternalsVisibleTo Include="bcltests" />
   </ItemGroup>
   <ItemGroup />
 </Project>
\ No newline at end of file

From 0aed4d2090ca2993afef016e192d50dcf0306c21 Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Tue, 5 Dec 2023 14:08:30 -0800
Subject: [PATCH 77/94] Make methods public for burst testing.

---
 src/Unity.Mathematics/Unity.Mathematics.csproj | 2 --
 src/Unity.Mathematics/svd.cs                   | 4 ++--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/Unity.Mathematics/Unity.Mathematics.csproj b/src/Unity.Mathematics/Unity.Mathematics.csproj
index a87b134b..6a97724f 100644
--- a/src/Unity.Mathematics/Unity.Mathematics.csproj
+++ b/src/Unity.Mathematics/Unity.Mathematics.csproj
@@ -16,8 +16,6 @@
     <!-- Allows targeting net471 on non-Windows platforms -->
     <PackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.0" PrivateAssets="All" />
     <InternalsVisibleTo Include="Unity.Mathematics.Tests" />
-    <InternalsVisibleTo Include="Burst.Compiler.IL.Tests" />
-    <InternalsVisibleTo Include="bcltests" />
   </ItemGroup>
   <ItemGroup />
 </Project>
\ No newline at end of file
diff --git a/src/Unity.Mathematics/svd.cs b/src/Unity.Mathematics/svd.cs
index fa50b669..d57e748a 100644
--- a/src/Unity.Mathematics/svd.cs
+++ b/src/Unity.Mathematics/svd.cs
@@ -151,7 +151,7 @@ static float3 rcpsafe(float3 x, float epsilon = k_EpsilonRCP) =>
             math.select(math.rcp(x), float3.zero, math.abs(x) < epsilon);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static float3x3 svdInverse(float3x3 a)
+        public static float3x3 svdInverse(float3x3 a)
         {
             var e = singularValuesDecomposition(a, out var u, out var v);
             var um = math.float3x3(u);
@@ -161,7 +161,7 @@ internal static float3x3 svdInverse(float3x3 a)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static quaternion svdRotation(float3x3 a)
+        public static quaternion svdRotation(float3x3 a)
         {
             singularValuesDecomposition(a, out var u, out var v);
             return math.mul(u, math.conjugate(v));

From 61c80455fd31a969684f6d7ea546cd90197a53da Mon Sep 17 00:00:00 2001
From: Dale Kim <3121968+unpacklo@users.noreply.github.com>
Date: Thu, 7 Dec 2023 13:12:57 -0800
Subject: [PATCH 78/94] Use only TestCompiler or TestCase, not both. Using both
 breaks burst testing.

---
 src/Tests/Tests/Shared/TestAffineTransform.cs |  28 +-
 src/Tests/Tests/Shared/TestBitmanipulation.cs | 122 +--
 src/Tests/Tests/Shared/TestBool2.gen.cs       |  40 +-
 src/Tests/Tests/Shared/TestBool2x2.gen.cs     |  32 +-
 src/Tests/Tests/Shared/TestBool2x3.gen.cs     |  32 +-
 src/Tests/Tests/Shared/TestBool2x4.gen.cs     |  32 +-
 src/Tests/Tests/Shared/TestBool3.gen.cs       |  40 +-
 src/Tests/Tests/Shared/TestBool3x2.gen.cs     |  32 +-
 src/Tests/Tests/Shared/TestBool3x3.gen.cs     |  32 +-
 src/Tests/Tests/Shared/TestBool3x4.gen.cs     |  32 +-
 src/Tests/Tests/Shared/TestBool4.gen.cs       |  40 +-
 src/Tests/Tests/Shared/TestBool4x2.gen.cs     |  32 +-
 src/Tests/Tests/Shared/TestBool4x3.gen.cs     |  32 +-
 src/Tests/Tests/Shared/TestBool4x4.gen.cs     |  32 +-
 src/Tests/Tests/Shared/TestDouble2.gen.cs     |  96 +-
 src/Tests/Tests/Shared/TestDouble2x2.gen.cs   |  82 +-
 src/Tests/Tests/Shared/TestDouble2x3.gen.cs   |  80 +-
 src/Tests/Tests/Shared/TestDouble2x4.gen.cs   |  80 +-
 src/Tests/Tests/Shared/TestDouble3.gen.cs     |  96 +-
 src/Tests/Tests/Shared/TestDouble3x2.gen.cs   |  80 +-
 src/Tests/Tests/Shared/TestDouble3x3.gen.cs   |  82 +-
 src/Tests/Tests/Shared/TestDouble3x4.gen.cs   |  80 +-
 src/Tests/Tests/Shared/TestDouble4.gen.cs     |  96 +-
 src/Tests/Tests/Shared/TestDouble4x2.gen.cs   |  80 +-
 src/Tests/Tests/Shared/TestDouble4x3.gen.cs   |  80 +-
 src/Tests/Tests/Shared/TestDouble4x4.gen.cs   |  82 +-
 src/Tests/Tests/Shared/TestFloat2.gen.cs      |  96 +-
 src/Tests/Tests/Shared/TestFloat2x2.gen.cs    |  82 +-
 src/Tests/Tests/Shared/TestFloat2x3.gen.cs    |  80 +-
 src/Tests/Tests/Shared/TestFloat2x4.gen.cs    |  80 +-
 src/Tests/Tests/Shared/TestFloat3.gen.cs      |  96 +-
 src/Tests/Tests/Shared/TestFloat3x2.gen.cs    |  80 +-
 src/Tests/Tests/Shared/TestFloat3x3.gen.cs    |  82 +-
 src/Tests/Tests/Shared/TestFloat3x4.gen.cs    |  80 +-
 src/Tests/Tests/Shared/TestFloat4.gen.cs      |  96 +-
 src/Tests/Tests/Shared/TestFloat4x2.gen.cs    |  80 +-
 src/Tests/Tests/Shared/TestFloat4x3.gen.cs    |  80 +-
 src/Tests/Tests/Shared/TestFloat4x4.gen.cs    |  82 +-
 src/Tests/Tests/Shared/TestHalf.cs            |  90 +-
 src/Tests/Tests/Shared/TestInt2.gen.cs        | 120 +--
 src/Tests/Tests/Shared/TestInt2x2.gen.cs      | 106 +--
 src/Tests/Tests/Shared/TestInt2x3.gen.cs      | 104 +--
 src/Tests/Tests/Shared/TestInt2x4.gen.cs      | 104 +--
 src/Tests/Tests/Shared/TestInt3.gen.cs        | 120 +--
 src/Tests/Tests/Shared/TestInt3x2.gen.cs      | 104 +--
 src/Tests/Tests/Shared/TestInt3x3.gen.cs      | 106 +--
 src/Tests/Tests/Shared/TestInt3x4.gen.cs      | 104 +--
 src/Tests/Tests/Shared/TestInt4.gen.cs        | 120 +--
 src/Tests/Tests/Shared/TestInt4x2.gen.cs      | 104 +--
 src/Tests/Tests/Shared/TestInt4x3.gen.cs      | 104 +--
 src/Tests/Tests/Shared/TestInt4x4.gen.cs      | 106 +--
 src/Tests/Tests/Shared/TestMath.cs            | 568 ++++++------
 src/Tests/Tests/Shared/TestMath.gen.cs        | 820 +++++++++---------
 src/Tests/Tests/Shared/TestMatrix.cs          | 122 +--
 src/Tests/Tests/Shared/TestMinMaxAABB.cs      |  90 +-
 src/Tests/Tests/Shared/TestPlane.cs           |  46 +-
 src/Tests/Tests/Shared/TestQuaternion.cs      |  56 +-
 src/Tests/Tests/Shared/TestRigidTransform.cs  |  16 +-
 src/Tests/Tests/Shared/TestSvd.cs             |  18 +-
 src/Tests/Tests/Shared/TestUint2.gen.cs       | 120 +--
 src/Tests/Tests/Shared/TestUint2x2.gen.cs     | 106 +--
 src/Tests/Tests/Shared/TestUint2x3.gen.cs     | 104 +--
 src/Tests/Tests/Shared/TestUint2x4.gen.cs     | 104 +--
 src/Tests/Tests/Shared/TestUint3.gen.cs       | 120 +--
 src/Tests/Tests/Shared/TestUint3x2.gen.cs     | 104 +--
 src/Tests/Tests/Shared/TestUint3x3.gen.cs     | 106 +--
 src/Tests/Tests/Shared/TestUint3x4.gen.cs     | 104 +--
 src/Tests/Tests/Shared/TestUint4.gen.cs       | 120 +--
 src/Tests/Tests/Shared/TestUint4x2.gen.cs     | 104 +--
 src/Tests/Tests/Shared/TestUint4x3.gen.cs     | 104 +--
 src/Tests/Tests/Shared/TestUint4x4.gen.cs     | 106 +--
 src/Tests/Tests/TestMath2.cs                  |   4 +-
 src/Tests/Tests/TestRandom.cs                 | 232 ++---
 .../VectorGenerator.cs                        |   2 +-
 74 files changed, 3627 insertions(+), 3627 deletions(-)

diff --git a/src/Tests/Tests/Shared/TestAffineTransform.cs b/src/Tests/Tests/Shared/TestAffineTransform.cs
index 77af61f8..b663fd65 100644
--- a/src/Tests/Tests/Shared/TestAffineTransform.cs
+++ b/src/Tests/Tests/Shared/TestAffineTransform.cs
@@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     class TestAffineTransform
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void affine_transform_construct_from_float3x3()
         {
             const float tolerance = 1e-6f;
@@ -20,7 +20,7 @@ public static void affine_transform_construct_from_float3x3()
             TestUtils.AreEqual(m3x3, testM3x3, tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void affine_transform_construct_from_float3x4()
         {
             const float tolerance = 1e-6f;
@@ -33,7 +33,7 @@ public static void affine_transform_construct_from_float3x4()
             TestUtils.AreEqual(m3x4, testM3x4, tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void affine_transform_construct_from_float4x4()
         {
             const float tolerance = 1e-6f;
@@ -46,7 +46,7 @@ public static void affine_transform_construct_from_float4x4()
             TestUtils.AreEqual(m4x4, testM4x4, tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void affine_transform_construct_from_RigidTransform()
         {
             const float tolerance = 1e-6f;
@@ -58,7 +58,7 @@ public static void affine_transform_construct_from_RigidTransform()
             TestUtils.AreEqual(r.pos, tx.t, tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void affine_transform_inverse()
         {
             const float tolerance = 1e-6f;
@@ -69,7 +69,7 @@ public static void affine_transform_inverse()
             TestUtils.AreEqual(float4x4.identity, mul(tx, invTx), tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void affine_transform_inverse_zero_rs_returns_zero()
         {
             const float tolerance = 1e-30f;
@@ -80,7 +80,7 @@ public static void affine_transform_inverse_zero_rs_returns_zero()
             TestUtils.AreEqual(float3x4.zero, invTx, tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void affine_transform_inverse_pico_scale()
         {
             // slightly larger tolerance (vs 1e-6f) for PS4
@@ -92,7 +92,7 @@ public static void affine_transform_inverse_pico_scale()
             TestUtils.AreEqual(float4x4.identity, mul(tx, invTx), tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void affine_transform_inverse_singular()
         {
             // it needs a bit larger tolerance for singular
@@ -107,7 +107,7 @@ public static void affine_transform_inverse_singular()
             TestUtils.AreEqual(float4x4(tx), float4x4(testTx), tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void affine_transform_decompose()
         {
             const float tolerance = 1e-6f;
@@ -120,7 +120,7 @@ public static void affine_transform_decompose()
             TestUtils.AreEqual(float4x4(tx), float4x4(testTx), tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void affine_transform_mul_vector()
         {
             float4x4 m = TestMatrix.test4x4_xyz;
@@ -137,7 +137,7 @@ public static void affine_transform_mul_vector()
             TestUtils.AreEqual(mvector1, txvector1, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void affine_transform_rotate_vector()
         {
             float3x3 m = TestMatrix.test3x3_xyz;
@@ -150,7 +150,7 @@ public static void affine_transform_rotate_vector()
             TestUtils.AreEqual(mvector0, txvector0, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void affine_transform_transform_point()
         {
             float4x4 m = float4x4(TestMatrix.test3x3_zyx, float3(1f, 2f, 3f));
@@ -163,11 +163,11 @@ public static void affine_transform_transform_point()
             TestUtils.AreEqual(mPt0, txPt0, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void affine_transform_zero()
         {
             TestUtils.AreEqual(float3x3.zero, AffineTransform.zero.rs);
             TestUtils.AreEqual(float3.zero, AffineTransform.zero.t);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Tests/Tests/Shared/TestBitmanipulation.cs b/src/Tests/Tests/Shared/TestBitmanipulation.cs
index e3c91791..517d8d67 100644
--- a/src/Tests/Tests/Shared/TestBitmanipulation.cs
+++ b/src/Tests/Tests/Shared/TestBitmanipulation.cs
@@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBitmanipulation
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bitmask_bool4()
         {
             TestUtils.AreEqual(bitmask(new bool4(false, false, false, false)), 0b0000);
@@ -23,7 +23,7 @@ public static void bitmask_bool4()
             TestUtils.AreEqual(bitmask(new bool4(true, true, true, false)), 0b0111);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void countbits_int1()
         {
             TestUtils.AreEqual(12, countbits( 0x01234567));
@@ -33,7 +33,7 @@ public static void countbits_int1()
             TestUtils.AreEqual(32, countbits(-1));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void countbits_int2()
         {
             TestUtils.AreEqual(int2(0, 12), countbits(int2(0, 0x01234567)));
@@ -41,21 +41,21 @@ public static void countbits_int2()
             TestUtils.AreEqual(int2(17, 32), countbits(int2(-0x456789AB, -1)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void countbits_int3()
         {
             TestUtils.AreEqual(int3(0, 12, 16), countbits(int3(0, 0x01234567, 0x456789AB)));
             TestUtils.AreEqual(int3(21, 17, 32), countbits(int3(-0x01234567, -0x456789AB, -1)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void countbits_int4()
         {
             TestUtils.AreEqual(int4(0, 12, 16, 21), countbits(int4(0, 0x01234567, 0x456789AB, -0x01234567)));
             TestUtils.AreEqual(int4(17, 32, 30, 29), countbits(int4(-0x456789AB, -1, -7, -15)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void countbits_uint()
         {
             TestUtils.AreEqual(0, countbits(0u));
@@ -66,7 +66,7 @@ public static void countbits_uint()
             TestUtils.AreEqual(32, countbits(0xFFFFFFFFu));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void countbits_uint2()
         {
             TestUtils.AreEqual(int2(0, 12), countbits(uint2(0, 0x01234567)));
@@ -74,21 +74,21 @@ public static void countbits_uint2()
             TestUtils.AreEqual(int2(16, 32), countbits(uint2(0xCDEF0123u, 0xFFFFFFFFu)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void countbits_uint3()
         {
             TestUtils.AreEqual(int3(0, 12, 16), countbits(uint3(0, 0x01234567, 0x456789AB)));
             TestUtils.AreEqual(int3(20, 16, 32), countbits(uint3(0x89ABCDEFu, 0xCDEF0123u, 0xFFFFFFFFu)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void countbits_uint4()
         {
             TestUtils.AreEqual(int4(0, 12, 16, 20), countbits(uint4(0, 0x01234567, 0x456789AB, 0x89ABCDEFu)));
             TestUtils.AreEqual(int4(16, 32, 30, 29), countbits(uint4(0xCDEF0123u, 0xFFFFFFFFu, 0xFFFFFFF5u, 0xFFFFFFF1u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void countbits_long()
         {
             TestUtils.AreEqual(0, countbits(0L));
@@ -97,7 +97,7 @@ public static void countbits_long()
             TestUtils.AreEqual(64, countbits(-1L));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void countbits_ulong()
         {
             TestUtils.AreEqual(0, countbits(0UL));
@@ -106,7 +106,7 @@ public static void countbits_ulong()
             TestUtils.AreEqual(64, countbits(0xFFFFFFFFFFFFFFFFUL));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lzcnt_int()
         {
             TestUtils.AreEqual(32, lzcnt(0));
@@ -119,7 +119,7 @@ public static void lzcnt_int()
             TestUtils.AreEqual(0, lzcnt(-2147483648));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lzcnt_int2()
         {
             TestUtils.AreEqual(int2(32, 31), lzcnt(int2(0, 1)));
@@ -128,7 +128,7 @@ public static void lzcnt_int2()
             TestUtils.AreEqual(int2(0, 0), lzcnt(int2(-1, -2147483648)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lzcnt_int3()
         {
             TestUtils.AreEqual(int3(32, 31, 30), lzcnt(int3(0, 1, 2)));
@@ -136,14 +136,14 @@ public static void lzcnt_int3()
             TestUtils.AreEqual(int3(0, 0, 27), lzcnt(int3(-1, -2147483648, 17)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lzcnt_int4()
         {
             TestUtils.AreEqual(int4(32, 31, 30, 30), lzcnt(int4(0, 1, 2, 3)));
             TestUtils.AreEqual(int4(17, 5, 0, 0), lzcnt(int4(0x5321, 0x04435321, -1, -2147483648)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lzcnt_uint()
         {
             TestUtils.AreEqual(32, lzcnt(0u));
@@ -156,7 +156,7 @@ public static void lzcnt_uint()
             TestUtils.AreEqual(0, lzcnt(0xFFFFFFFFu));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lzcnt_uint2()
         {
             TestUtils.AreEqual(int2(32, 31), lzcnt(uint2(0u, 1u)));
@@ -165,7 +165,7 @@ public static void lzcnt_uint2()
             TestUtils.AreEqual(int2(0, 0), lzcnt(uint2(0x84435320u, 0xFFFFFFFFu)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lzcnt_uint3()
         {
             TestUtils.AreEqual(int3(32, 31, 30), lzcnt(uint3(0u, 1u, 2u)));
@@ -173,7 +173,7 @@ public static void lzcnt_uint3()
             TestUtils.AreEqual(int3(0, 0, 27), lzcnt(uint3(0x84435320u, 0xFFFFFFFFu, 17)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lzcnt_uint4()
         {
             TestUtils.AreEqual(int2(32, 31), lzcnt(uint2(0u, 1u)));
@@ -182,7 +182,7 @@ public static void lzcnt_uint4()
             TestUtils.AreEqual(int2(0, 0), lzcnt(uint2(0x84435320u, 0xFFFFFFFFu)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lzcnt_long()
         {
             TestUtils.AreEqual(64, lzcnt(0L));
@@ -194,7 +194,7 @@ public static void lzcnt_long()
             TestUtils.AreEqual(0, lzcnt(-9223372036854775808L));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lzcnt_ulong()
         {
             TestUtils.AreEqual(64, lzcnt(0UL));
@@ -206,7 +206,7 @@ public static void lzcnt_ulong()
             TestUtils.AreEqual(0, lzcnt(0x8000000000000000UL));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tzcnt_int()
         {
             TestUtils.AreEqual(32, tzcnt(0));
@@ -220,7 +220,7 @@ public static void tzcnt_int()
             TestUtils.AreEqual(31, tzcnt(-2147483648));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tzcnt_int2()
         {
             TestUtils.AreEqual(int2(32, 0), tzcnt(int2(0, 1)));
@@ -230,7 +230,7 @@ public static void tzcnt_int2()
             TestUtils.AreEqual(int2(31, 2), tzcnt(int2(-2147483648, 20)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tzcnt_int3()
         {
             TestUtils.AreEqual(int3(32, 0, 1), tzcnt(int3(0, 1, 2)));
@@ -238,7 +238,7 @@ public static void tzcnt_int3()
             TestUtils.AreEqual(int3(1, 0, 31), tzcnt(int3(-2, -2147483647, -2147483648)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tzcnt_int4()
         {
             TestUtils.AreEqual(int4(32, 0, 1, 0), tzcnt(int4(0, 1, 2, 3)));
@@ -246,7 +246,7 @@ public static void tzcnt_int4()
             TestUtils.AreEqual(int4(31, 2, 2, 3), tzcnt(int4(-2147483648, 20, 4132, -8)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tzcnt_uint()
         {
             TestUtils.AreEqual(32, tzcnt(0u));
@@ -260,7 +260,7 @@ public static void tzcnt_uint()
             TestUtils.AreEqual(31, tzcnt(0x80000000u));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tzcnt_uint2()
         {
             TestUtils.AreEqual(int2(32, 0), tzcnt(uint2(0u, 1u)));
@@ -270,7 +270,7 @@ public static void tzcnt_uint2()
             TestUtils.AreEqual(int2(31, 2), tzcnt(uint2(0x80000000u, 20u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tzcnt_uint3()
         {
             TestUtils.AreEqual(int3(32, 0, 1), tzcnt(uint3(0u, 1u, 2u)));
@@ -278,7 +278,7 @@ public static void tzcnt_uint3()
             TestUtils.AreEqual(int3(1, 0, 31), tzcnt(uint3(0xFFFFFFFEu, 0x80000001u, 0x80000000u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tzcnt_uint4()
         {
             TestUtils.AreEqual(int4(32, 0, 1, 0), tzcnt(uint4(0u, 1u, 2u, 3u)));
@@ -286,7 +286,7 @@ public static void tzcnt_uint4()
             TestUtils.AreEqual(int4(31, 2, 2, 3), tzcnt(uint4(0x80000000u, 20u, 4132u, 0xFFFFFFF8u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tzcnt_long()
         {
             TestUtils.AreEqual(64, tzcnt(0L));
@@ -298,7 +298,7 @@ public static void tzcnt_long()
             TestUtils.AreEqual(0, tzcnt(-9223372036854775807L));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tzcnt_ulong()
         {
             TestUtils.AreEqual(64, tzcnt(0UL));
@@ -310,7 +310,7 @@ public static void tzcnt_ulong()
             TestUtils.AreEqual(0, tzcnt(0x8000000000000001UL));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void reversebits_int()
         {
             TestUtils.AreEqual(0x03521609, reversebits(-1872213312));
@@ -319,27 +319,27 @@ public static void reversebits_int()
             TestUtils.AreEqual(0x48d9c42e, reversebits(0x74239b12));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void reversebits_int2()
         {
             TestUtils.AreEqual(int2(0x03521609, 0x5f5b0648), reversebits(int2(-1872213312, 0x1260dafa)));
             TestUtils.AreEqual(int2(0x4bbafd8d, 0x48d9c42e), reversebits(int2(-1312858670, 0x74239b12)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void reversebits_int3()
         {
             TestUtils.AreEqual(int3(0x03521609, 0x5f5b0648, 0x4bbafd8d), reversebits(int3(-1872213312, 0x1260dafa, -1312858670)));
             TestUtils.AreEqual(int3(0x48d9c42e, 0, -1), reversebits(int3(0x74239b12, 0, -1)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void reversebits_int4()
         {
             TestUtils.AreEqual(int4(0x03521609, 0x5f5b0648, 0x4bbafd8d, 0x48d9c42e), reversebits(int4(-1872213312, 0x1260dafa, -1312858670, 0x74239b12)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void reversebits_uint()
         {
             TestUtils.AreEqual(0x03521609u, reversebits(0x90684ac0u));
@@ -348,39 +348,39 @@ public static void reversebits_uint()
             TestUtils.AreEqual(0x48d9c42eu, reversebits(0x74239b12u));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void reversebits_uint2()
         {
             TestUtils.AreEqual(uint2(0x03521609u, 0x5f5b0648u), reversebits(uint2(0x90684ac0u, 0x1260dafau)));
             TestUtils.AreEqual(uint2(0x4bbafd8du, 0x48d9c42eu), reversebits(uint2(0xb1bf5dd2u, 0x74239b12u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void reversebits_uint3()
         {
             TestUtils.AreEqual(uint3(0x03521609u, 0x5f5b0648u, 0x4bbafd8du), reversebits(uint3(0x90684ac0u, 0x1260dafau, 0xb1bf5dd2u)));
             TestUtils.AreEqual(uint3(0x48d9c42eu, 0u, 0xFFFFFFFF), reversebits(uint3(0x74239b12u, 0u, 0xFFFFFFFF)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void reversebits_uint4()
         {
             TestUtils.AreEqual(uint4(0x03521609u, 0x5f5b0648u, 0x4bbafd8du, 0x48d9c42eu), reversebits(uint4(0x90684ac0u, 0x1260dafau, 0xb1bf5dd2u, 0x74239b12u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void reversebits_long()
         {
             TestUtils.AreEqual(0x4bbafd8d5f5b0648L, reversebits(0x1260dafab1bf5dd2L));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void reversebits_ulong()
         {
             TestUtils.AreEqual(0x4bbafd8d5f5b0648ul, reversebits(0x1260dafab1bf5dd2ul));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rol_int()
         {
             TestUtils.AreEqual(-1933184920, rol(219257022, 11));
@@ -389,27 +389,27 @@ public static void rol_int()
             TestUtils.AreEqual(661621977, rol(-1692078607, 11));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rol_int2()
         {
             TestUtils.AreEqual(int2(-1933184920, -2048170741), rol(int2(219257022, -1586446996), 11));
             TestUtils.AreEqual(int2(-1152739462, 661621977), rol(int2(-279484078, -1692078607), 11));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rol_int3()
         {
             TestUtils.AreEqual(int3(-1933184920, -2048170741, -1152739462), rol(int3(219257022, -1586446996, -279484078), 11));
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rol_int4()
         {
             TestUtils.AreEqual(int4(-1933184920, -2048170741, -1152739462, 661621977), rol(int4(219257022, -1586446996, -279484078, -1692078607), 11));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rol_uint()
         {
             TestUtils.AreEqual(2361782376u, rol(219257022u, 11));
@@ -418,27 +418,27 @@ public static void rol_uint()
             TestUtils.AreEqual(661621977u, rol(2602888689u, 11));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rol_uint2()
         {
             TestUtils.AreEqual(uint2(2361782376u, 2246796555u), rol(uint2(219257022u, 2708520300u), 11));
             TestUtils.AreEqual(uint2(3142227834u, 661621977u), rol(uint2(4015483218u, 2602888689u), 11));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rol_uint3()
         {
             TestUtils.AreEqual(uint3(2361782376u, 2246796555u, 3142227834u), rol(uint3(219257022u, 2708520300u, 4015483218u), 11));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rol_uint4()
         {
             TestUtils.AreEqual(uint4(2361782376u, 2246796555u, 3142227834u, 661621977u), rol(uint4(219257022u, 2708520300u, 4015483218u, 2602888689u), 11));
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rol_long()
         {
             TestUtils.AreEqual(4769317691753349395L, rol(6894885722123239465L, 37));
@@ -447,7 +447,7 @@ public static void rol_long()
             TestUtils.AreEqual(-5493728106787075631L, rol(2788577329702376155L, 37));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rol_ulong()
         {
             TestUtils.AreEqual(4769317691753349395UL, rol(6894885722123239465UL, 37));
@@ -457,7 +457,7 @@ public static void rol_ulong()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ror_int()
         {
             TestUtils.AreEqual(87245360, ror(-1710129111, 11));
@@ -466,27 +466,27 @@ public static void ror_int()
             TestUtils.AreEqual(-232831845, ror(-98246768, 11));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ror_int2()
         {
             TestUtils.AreEqual(int2(87245360, -259445220), ror(int2(-1710129111, 1232136068), 11));
             TestUtils.AreEqual(int2(-1697813787, -232831845), ror(int2(1800875222, -98246768), 11));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ror_int3()
         {
             TestUtils.AreEqual(int3(87245360, -259445220, -1697813787), ror(int3(-1710129111, 1232136068, 1800875222), 11));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ror_int4()
         {
             TestUtils.AreEqual(int4(87245360, -259445220, -1697813787, -232831845), ror(int4(-1710129111, 1232136068, 1800875222, -98246768), 11));
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ror_uint()
         {
             TestUtils.AreEqual(87245360u, ror(2584838185u, 11));
@@ -495,26 +495,26 @@ public static void ror_uint()
             TestUtils.AreEqual(4062135451u, ror(4196720528u, 11));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ror_uint2()
         {
             TestUtils.AreEqual(uint2(87245360u, 4035522076u), ror(uint2(2584838185u, 1232136068u), 11));
             TestUtils.AreEqual(uint2(2597153509u, 4062135451u), ror(uint2(1800875222u, 4196720528u), 11));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ror_uint3()
         {
             TestUtils.AreEqual(uint3(87245360u, 4035522076u, 2597153509u), ror(uint3(2584838185u, 1232136068u, 1800875222u), 11));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ror_uint4()
         {
             TestUtils.AreEqual(uint4(87245360u, 4035522076u, 2597153509u, 4062135451u), ror(uint4(2584838185u, 1232136068u, 1800875222u, 4196720528u), 11));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ror_long()
         {
             TestUtils.AreEqual(4958617126915898480L, ror(6894885722123239465L, 37));
@@ -523,7 +523,7 @@ public static void ror_long()
             TestUtils.AreEqual(8389344736564320290L, ror(2788577329702376155L, 37));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ror_ulong()
         {
             TestUtils.AreEqual(4958617126915898480UL, ror(6894885722123239465UL, 37));
diff --git a/src/Tests/Tests/Shared/TestBool2.gen.cs b/src/Tests/Tests/Shared/TestBool2.gen.cs
index fe9ee45c..11c32ff2 100644
--- a/src/Tests/Tests/Shared/TestBool2.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_constructor()
         {
             bool2 a = new bool2(false, true);
@@ -23,7 +23,7 @@ public static void bool2_constructor()
             TestUtils.AreEqual(true, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_scalar_constructor()
         {
             bool2 a = new bool2(true);
@@ -31,7 +31,7 @@ public static void bool2_scalar_constructor()
             TestUtils.AreEqual(true, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_static_constructor()
         {
             bool2 a = bool2(false, true);
@@ -39,7 +39,7 @@ public static void bool2_static_constructor()
             TestUtils.AreEqual(true, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_static_scalar_constructor()
         {
             bool2 a = bool2(true);
@@ -47,7 +47,7 @@ public static void bool2_static_scalar_constructor()
             TestUtils.AreEqual(true, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_operator_equal_wide_wide()
         {
             bool2 a0 = bool2(true, false);
@@ -71,7 +71,7 @@ public static void bool2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_operator_equal_wide_scalar()
         {
             bool2 a0 = bool2(false, true);
@@ -95,7 +95,7 @@ public static void bool2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -119,7 +119,7 @@ public static void bool2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_operator_not_equal_wide_wide()
         {
             bool2 a0 = bool2(true, true);
@@ -143,7 +143,7 @@ public static void bool2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_operator_not_equal_wide_scalar()
         {
             bool2 a0 = bool2(false, true);
@@ -167,7 +167,7 @@ public static void bool2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -191,7 +191,7 @@ public static void bool2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_operator_bitwise_and_wide_wide()
         {
             bool2 a0 = bool2(false, false);
@@ -215,7 +215,7 @@ public static void bool2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_operator_bitwise_and_wide_scalar()
         {
             bool2 a0 = bool2(true, false);
@@ -239,7 +239,7 @@ public static void bool2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -263,7 +263,7 @@ public static void bool2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_operator_bitwise_or_wide_wide()
         {
             bool2 a0 = bool2(true, true);
@@ -287,7 +287,7 @@ public static void bool2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_operator_bitwise_or_wide_scalar()
         {
             bool2 a0 = bool2(true, true);
@@ -311,7 +311,7 @@ public static void bool2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -335,7 +335,7 @@ public static void bool2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_operator_bitwise_xor_wide_wide()
         {
             bool2 a0 = bool2(true, false);
@@ -359,7 +359,7 @@ public static void bool2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_operator_bitwise_xor_wide_scalar()
         {
             bool2 a0 = bool2(false, false);
@@ -383,7 +383,7 @@ public static void bool2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -407,7 +407,7 @@ public static void bool2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_operator_logical_not()
         {
             bool2 a0 = bool2(true, true);
diff --git a/src/Tests/Tests/Shared/TestBool2x2.gen.cs b/src/Tests/Tests/Shared/TestBool2x2.gen.cs
index af2bb68c..1646031c 100644
--- a/src/Tests/Tests/Shared/TestBool2x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool2x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool2x2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x2_operator_equal_wide_wide()
         {
             bool2x2 a0 = bool2x2(true, false, true, false);
@@ -39,7 +39,7 @@ public static void bool2x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x2_operator_equal_wide_scalar()
         {
             bool2x2 a0 = bool2x2(false, true, false, false);
@@ -63,7 +63,7 @@ public static void bool2x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x2_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool2x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x2_operator_not_equal_wide_wide()
         {
             bool2x2 a0 = bool2x2(true, true, true, false);
@@ -111,7 +111,7 @@ public static void bool2x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x2_operator_not_equal_wide_scalar()
         {
             bool2x2 a0 = bool2x2(false, true, false, true);
@@ -135,7 +135,7 @@ public static void bool2x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x2_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool2x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x2_operator_bitwise_and_wide_wide()
         {
             bool2x2 a0 = bool2x2(false, false, true, true);
@@ -183,7 +183,7 @@ public static void bool2x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x2_operator_bitwise_and_wide_scalar()
         {
             bool2x2 a0 = bool2x2(true, false, false, true);
@@ -207,7 +207,7 @@ public static void bool2x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x2_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool2x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x2_operator_bitwise_or_wide_wide()
         {
             bool2x2 a0 = bool2x2(true, true, true, false);
@@ -255,7 +255,7 @@ public static void bool2x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x2_operator_bitwise_or_wide_scalar()
         {
             bool2x2 a0 = bool2x2(true, true, false, true);
@@ -279,7 +279,7 @@ public static void bool2x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x2_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool2x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x2_operator_bitwise_xor_wide_wide()
         {
             bool2x2 a0 = bool2x2(true, false, false, true);
@@ -327,7 +327,7 @@ public static void bool2x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x2_operator_bitwise_xor_wide_scalar()
         {
             bool2x2 a0 = bool2x2(false, false, true, true);
@@ -351,7 +351,7 @@ public static void bool2x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x2_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool2x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x2_operator_logical_not()
         {
             bool2x2 a0 = bool2x2(true, true, false, false);
diff --git a/src/Tests/Tests/Shared/TestBool2x3.gen.cs b/src/Tests/Tests/Shared/TestBool2x3.gen.cs
index bf0f34d2..8157a008 100644
--- a/src/Tests/Tests/Shared/TestBool2x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool2x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool2x3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x3_operator_equal_wide_wide()
         {
             bool2x3 a0 = bool2x3(true, false, true, false, false, true);
@@ -39,7 +39,7 @@ public static void bool2x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x3_operator_equal_wide_scalar()
         {
             bool2x3 a0 = bool2x3(false, true, false, false, false, false);
@@ -63,7 +63,7 @@ public static void bool2x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x3_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool2x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x3_operator_not_equal_wide_wide()
         {
             bool2x3 a0 = bool2x3(true, true, true, false, false, true);
@@ -111,7 +111,7 @@ public static void bool2x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x3_operator_not_equal_wide_scalar()
         {
             bool2x3 a0 = bool2x3(false, true, false, true, true, false);
@@ -135,7 +135,7 @@ public static void bool2x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x3_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool2x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x3_operator_bitwise_and_wide_wide()
         {
             bool2x3 a0 = bool2x3(false, false, true, true, false, false);
@@ -183,7 +183,7 @@ public static void bool2x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x3_operator_bitwise_and_wide_scalar()
         {
             bool2x3 a0 = bool2x3(true, false, false, true, true, false);
@@ -207,7 +207,7 @@ public static void bool2x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x3_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool2x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x3_operator_bitwise_or_wide_wide()
         {
             bool2x3 a0 = bool2x3(true, true, true, false, true, false);
@@ -255,7 +255,7 @@ public static void bool2x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x3_operator_bitwise_or_wide_scalar()
         {
             bool2x3 a0 = bool2x3(true, true, false, true, true, true);
@@ -279,7 +279,7 @@ public static void bool2x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x3_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool2x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x3_operator_bitwise_xor_wide_wide()
         {
             bool2x3 a0 = bool2x3(true, false, false, true, false, false);
@@ -327,7 +327,7 @@ public static void bool2x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x3_operator_bitwise_xor_wide_scalar()
         {
             bool2x3 a0 = bool2x3(false, false, true, true, false, false);
@@ -351,7 +351,7 @@ public static void bool2x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x3_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool2x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x3_operator_logical_not()
         {
             bool2x3 a0 = bool2x3(true, true, false, false, true, false);
diff --git a/src/Tests/Tests/Shared/TestBool2x4.gen.cs b/src/Tests/Tests/Shared/TestBool2x4.gen.cs
index 3310b755..fdfdb454 100644
--- a/src/Tests/Tests/Shared/TestBool2x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool2x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool2x4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x4_operator_equal_wide_wide()
         {
             bool2x4 a0 = bool2x4(true, false, true, false, false, true, false, false);
@@ -39,7 +39,7 @@ public static void bool2x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x4_operator_equal_wide_scalar()
         {
             bool2x4 a0 = bool2x4(false, true, false, false, false, false, true, false);
@@ -63,7 +63,7 @@ public static void bool2x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x4_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool2x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x4_operator_not_equal_wide_wide()
         {
             bool2x4 a0 = bool2x4(true, true, true, false, false, true, false, false);
@@ -111,7 +111,7 @@ public static void bool2x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x4_operator_not_equal_wide_scalar()
         {
             bool2x4 a0 = bool2x4(false, true, false, true, true, false, false, false);
@@ -135,7 +135,7 @@ public static void bool2x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x4_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool2x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x4_operator_bitwise_and_wide_wide()
         {
             bool2x4 a0 = bool2x4(false, false, true, true, false, false, true, true);
@@ -183,7 +183,7 @@ public static void bool2x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x4_operator_bitwise_and_wide_scalar()
         {
             bool2x4 a0 = bool2x4(true, false, false, true, true, false, false, false);
@@ -207,7 +207,7 @@ public static void bool2x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x4_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool2x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x4_operator_bitwise_or_wide_wide()
         {
             bool2x4 a0 = bool2x4(true, true, true, false, true, false, true, true);
@@ -255,7 +255,7 @@ public static void bool2x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x4_operator_bitwise_or_wide_scalar()
         {
             bool2x4 a0 = bool2x4(true, true, false, true, true, true, true, false);
@@ -279,7 +279,7 @@ public static void bool2x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x4_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool2x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x4_operator_bitwise_xor_wide_wide()
         {
             bool2x4 a0 = bool2x4(true, false, false, true, false, false, false, true);
@@ -327,7 +327,7 @@ public static void bool2x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x4_operator_bitwise_xor_wide_scalar()
         {
             bool2x4 a0 = bool2x4(false, false, true, true, false, false, false, false);
@@ -351,7 +351,7 @@ public static void bool2x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x4_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool2x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2x4_operator_logical_not()
         {
             bool2x4 a0 = bool2x4(true, true, false, false, true, false, true, false);
diff --git a/src/Tests/Tests/Shared/TestBool3.gen.cs b/src/Tests/Tests/Shared/TestBool3.gen.cs
index d66353aa..ee345f1e 100644
--- a/src/Tests/Tests/Shared/TestBool3.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_constructor()
         {
             bool3 a = new bool3(false, true, false);
@@ -24,7 +24,7 @@ public static void bool3_constructor()
             TestUtils.AreEqual(false, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_scalar_constructor()
         {
             bool3 a = new bool3(true);
@@ -33,7 +33,7 @@ public static void bool3_scalar_constructor()
             TestUtils.AreEqual(true, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_static_constructor()
         {
             bool3 a = bool3(false, true, false);
@@ -42,7 +42,7 @@ public static void bool3_static_constructor()
             TestUtils.AreEqual(false, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_static_scalar_constructor()
         {
             bool3 a = bool3(true);
@@ -51,7 +51,7 @@ public static void bool3_static_scalar_constructor()
             TestUtils.AreEqual(true, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_operator_equal_wide_wide()
         {
             bool3 a0 = bool3(true, false, true);
@@ -75,7 +75,7 @@ public static void bool3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_operator_equal_wide_scalar()
         {
             bool3 a0 = bool3(false, true, false);
@@ -99,7 +99,7 @@ public static void bool3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -123,7 +123,7 @@ public static void bool3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_operator_not_equal_wide_wide()
         {
             bool3 a0 = bool3(true, true, true);
@@ -147,7 +147,7 @@ public static void bool3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_operator_not_equal_wide_scalar()
         {
             bool3 a0 = bool3(false, true, false);
@@ -171,7 +171,7 @@ public static void bool3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -195,7 +195,7 @@ public static void bool3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_operator_bitwise_and_wide_wide()
         {
             bool3 a0 = bool3(false, false, true);
@@ -219,7 +219,7 @@ public static void bool3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_operator_bitwise_and_wide_scalar()
         {
             bool3 a0 = bool3(true, false, false);
@@ -243,7 +243,7 @@ public static void bool3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -267,7 +267,7 @@ public static void bool3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_operator_bitwise_or_wide_wide()
         {
             bool3 a0 = bool3(true, true, true);
@@ -291,7 +291,7 @@ public static void bool3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_operator_bitwise_or_wide_scalar()
         {
             bool3 a0 = bool3(true, true, false);
@@ -315,7 +315,7 @@ public static void bool3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -339,7 +339,7 @@ public static void bool3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_operator_bitwise_xor_wide_wide()
         {
             bool3 a0 = bool3(true, false, false);
@@ -363,7 +363,7 @@ public static void bool3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_operator_bitwise_xor_wide_scalar()
         {
             bool3 a0 = bool3(false, false, true);
@@ -387,7 +387,7 @@ public static void bool3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -411,7 +411,7 @@ public static void bool3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_operator_logical_not()
         {
             bool3 a0 = bool3(true, true, false);
diff --git a/src/Tests/Tests/Shared/TestBool3x2.gen.cs b/src/Tests/Tests/Shared/TestBool3x2.gen.cs
index 5be3fb7b..816c30fd 100644
--- a/src/Tests/Tests/Shared/TestBool3x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool3x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool3x2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x2_operator_equal_wide_wide()
         {
             bool3x2 a0 = bool3x2(true, false, true, false, false, true);
@@ -39,7 +39,7 @@ public static void bool3x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x2_operator_equal_wide_scalar()
         {
             bool3x2 a0 = bool3x2(false, true, false, false, false, false);
@@ -63,7 +63,7 @@ public static void bool3x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x2_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool3x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x2_operator_not_equal_wide_wide()
         {
             bool3x2 a0 = bool3x2(true, true, true, false, false, true);
@@ -111,7 +111,7 @@ public static void bool3x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x2_operator_not_equal_wide_scalar()
         {
             bool3x2 a0 = bool3x2(false, true, false, true, true, false);
@@ -135,7 +135,7 @@ public static void bool3x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x2_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool3x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x2_operator_bitwise_and_wide_wide()
         {
             bool3x2 a0 = bool3x2(false, false, true, true, false, false);
@@ -183,7 +183,7 @@ public static void bool3x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x2_operator_bitwise_and_wide_scalar()
         {
             bool3x2 a0 = bool3x2(true, false, false, true, true, false);
@@ -207,7 +207,7 @@ public static void bool3x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x2_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool3x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x2_operator_bitwise_or_wide_wide()
         {
             bool3x2 a0 = bool3x2(true, true, true, false, true, false);
@@ -255,7 +255,7 @@ public static void bool3x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x2_operator_bitwise_or_wide_scalar()
         {
             bool3x2 a0 = bool3x2(true, true, false, true, true, true);
@@ -279,7 +279,7 @@ public static void bool3x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x2_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool3x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x2_operator_bitwise_xor_wide_wide()
         {
             bool3x2 a0 = bool3x2(true, false, false, true, false, false);
@@ -327,7 +327,7 @@ public static void bool3x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x2_operator_bitwise_xor_wide_scalar()
         {
             bool3x2 a0 = bool3x2(false, false, true, true, false, false);
@@ -351,7 +351,7 @@ public static void bool3x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x2_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool3x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x2_operator_logical_not()
         {
             bool3x2 a0 = bool3x2(true, true, false, false, true, false);
diff --git a/src/Tests/Tests/Shared/TestBool3x3.gen.cs b/src/Tests/Tests/Shared/TestBool3x3.gen.cs
index 4541a352..6c5b1b9b 100644
--- a/src/Tests/Tests/Shared/TestBool3x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool3x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool3x3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x3_operator_equal_wide_wide()
         {
             bool3x3 a0 = bool3x3(true, false, true, false, false, true, false, false, true);
@@ -39,7 +39,7 @@ public static void bool3x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x3_operator_equal_wide_scalar()
         {
             bool3x3 a0 = bool3x3(false, true, false, false, false, false, true, false, false);
@@ -63,7 +63,7 @@ public static void bool3x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x3_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool3x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x3_operator_not_equal_wide_wide()
         {
             bool3x3 a0 = bool3x3(true, true, true, false, false, true, false, false, false);
@@ -111,7 +111,7 @@ public static void bool3x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x3_operator_not_equal_wide_scalar()
         {
             bool3x3 a0 = bool3x3(false, true, false, true, true, false, false, false, false);
@@ -135,7 +135,7 @@ public static void bool3x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x3_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool3x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x3_operator_bitwise_and_wide_wide()
         {
             bool3x3 a0 = bool3x3(false, false, true, true, false, false, true, true, true);
@@ -183,7 +183,7 @@ public static void bool3x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x3_operator_bitwise_and_wide_scalar()
         {
             bool3x3 a0 = bool3x3(true, false, false, true, true, false, false, false, false);
@@ -207,7 +207,7 @@ public static void bool3x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x3_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool3x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x3_operator_bitwise_or_wide_wide()
         {
             bool3x3 a0 = bool3x3(true, true, true, false, true, false, true, true, false);
@@ -255,7 +255,7 @@ public static void bool3x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x3_operator_bitwise_or_wide_scalar()
         {
             bool3x3 a0 = bool3x3(true, true, false, true, true, true, true, false, true);
@@ -279,7 +279,7 @@ public static void bool3x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x3_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool3x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x3_operator_bitwise_xor_wide_wide()
         {
             bool3x3 a0 = bool3x3(true, false, false, true, false, false, false, true, false);
@@ -327,7 +327,7 @@ public static void bool3x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x3_operator_bitwise_xor_wide_scalar()
         {
             bool3x3 a0 = bool3x3(false, false, true, true, false, false, false, false, false);
@@ -351,7 +351,7 @@ public static void bool3x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x3_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool3x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x3_operator_logical_not()
         {
             bool3x3 a0 = bool3x3(true, true, false, false, true, false, true, false, true);
diff --git a/src/Tests/Tests/Shared/TestBool3x4.gen.cs b/src/Tests/Tests/Shared/TestBool3x4.gen.cs
index 02565c51..8d7d6245 100644
--- a/src/Tests/Tests/Shared/TestBool3x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool3x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool3x4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x4_operator_equal_wide_wide()
         {
             bool3x4 a0 = bool3x4(true, false, true, false, false, true, false, false, true, false, true, false);
@@ -39,7 +39,7 @@ public static void bool3x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x4_operator_equal_wide_scalar()
         {
             bool3x4 a0 = bool3x4(false, true, false, false, false, false, true, false, false, false, true, true);
@@ -63,7 +63,7 @@ public static void bool3x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x4_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool3x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x4_operator_not_equal_wide_wide()
         {
             bool3x4 a0 = bool3x4(true, true, true, false, false, true, false, false, false, false, true, true);
@@ -111,7 +111,7 @@ public static void bool3x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x4_operator_not_equal_wide_scalar()
         {
             bool3x4 a0 = bool3x4(false, true, false, true, true, false, false, false, false, false, false, false);
@@ -135,7 +135,7 @@ public static void bool3x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x4_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool3x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x4_operator_bitwise_and_wide_wide()
         {
             bool3x4 a0 = bool3x4(false, false, true, true, false, false, true, true, true, false, true, true);
@@ -183,7 +183,7 @@ public static void bool3x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x4_operator_bitwise_and_wide_scalar()
         {
             bool3x4 a0 = bool3x4(true, false, false, true, true, false, false, false, false, false, true, true);
@@ -207,7 +207,7 @@ public static void bool3x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x4_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool3x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x4_operator_bitwise_or_wide_wide()
         {
             bool3x4 a0 = bool3x4(true, true, true, false, true, false, true, true, false, true, true, true);
@@ -255,7 +255,7 @@ public static void bool3x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x4_operator_bitwise_or_wide_scalar()
         {
             bool3x4 a0 = bool3x4(true, true, false, true, true, true, true, false, true, false, false, true);
@@ -279,7 +279,7 @@ public static void bool3x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x4_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool3x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x4_operator_bitwise_xor_wide_wide()
         {
             bool3x4 a0 = bool3x4(true, false, false, true, false, false, false, true, false, false, true, true);
@@ -327,7 +327,7 @@ public static void bool3x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x4_operator_bitwise_xor_wide_scalar()
         {
             bool3x4 a0 = bool3x4(false, false, true, true, false, false, false, false, false, false, false, true);
@@ -351,7 +351,7 @@ public static void bool3x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x4_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool3x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3x4_operator_logical_not()
         {
             bool3x4 a0 = bool3x4(true, true, false, false, true, false, true, false, true, false, false, false);
diff --git a/src/Tests/Tests/Shared/TestBool4.gen.cs b/src/Tests/Tests/Shared/TestBool4.gen.cs
index 4faf4e36..c2c8be05 100644
--- a/src/Tests/Tests/Shared/TestBool4.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_constructor()
         {
             bool4 a = new bool4(false, true, false, true);
@@ -25,7 +25,7 @@ public static void bool4_constructor()
             TestUtils.AreEqual(true, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_scalar_constructor()
         {
             bool4 a = new bool4(true);
@@ -35,7 +35,7 @@ public static void bool4_scalar_constructor()
             TestUtils.AreEqual(true, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_static_constructor()
         {
             bool4 a = bool4(false, true, false, true);
@@ -45,7 +45,7 @@ public static void bool4_static_constructor()
             TestUtils.AreEqual(true, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_static_scalar_constructor()
         {
             bool4 a = bool4(true);
@@ -55,7 +55,7 @@ public static void bool4_static_scalar_constructor()
             TestUtils.AreEqual(true, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_operator_equal_wide_wide()
         {
             bool4 a0 = bool4(true, false, true, false);
@@ -79,7 +79,7 @@ public static void bool4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_operator_equal_wide_scalar()
         {
             bool4 a0 = bool4(false, true, false, false);
@@ -103,7 +103,7 @@ public static void bool4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -127,7 +127,7 @@ public static void bool4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_operator_not_equal_wide_wide()
         {
             bool4 a0 = bool4(true, true, true, false);
@@ -151,7 +151,7 @@ public static void bool4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_operator_not_equal_wide_scalar()
         {
             bool4 a0 = bool4(false, true, false, true);
@@ -175,7 +175,7 @@ public static void bool4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -199,7 +199,7 @@ public static void bool4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_operator_bitwise_and_wide_wide()
         {
             bool4 a0 = bool4(false, false, true, true);
@@ -223,7 +223,7 @@ public static void bool4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_operator_bitwise_and_wide_scalar()
         {
             bool4 a0 = bool4(true, false, false, true);
@@ -247,7 +247,7 @@ public static void bool4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -271,7 +271,7 @@ public static void bool4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_operator_bitwise_or_wide_wide()
         {
             bool4 a0 = bool4(true, true, true, false);
@@ -295,7 +295,7 @@ public static void bool4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_operator_bitwise_or_wide_scalar()
         {
             bool4 a0 = bool4(true, true, false, true);
@@ -319,7 +319,7 @@ public static void bool4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -343,7 +343,7 @@ public static void bool4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_operator_bitwise_xor_wide_wide()
         {
             bool4 a0 = bool4(true, false, false, true);
@@ -367,7 +367,7 @@ public static void bool4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_operator_bitwise_xor_wide_scalar()
         {
             bool4 a0 = bool4(false, false, true, true);
@@ -391,7 +391,7 @@ public static void bool4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -415,7 +415,7 @@ public static void bool4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_operator_logical_not()
         {
             bool4 a0 = bool4(true, true, false, false);
diff --git a/src/Tests/Tests/Shared/TestBool4x2.gen.cs b/src/Tests/Tests/Shared/TestBool4x2.gen.cs
index b7585d45..40511294 100644
--- a/src/Tests/Tests/Shared/TestBool4x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool4x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool4x2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x2_operator_equal_wide_wide()
         {
             bool4x2 a0 = bool4x2(true, false, true, false, false, true, false, false);
@@ -39,7 +39,7 @@ public static void bool4x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x2_operator_equal_wide_scalar()
         {
             bool4x2 a0 = bool4x2(false, true, false, false, false, false, true, false);
@@ -63,7 +63,7 @@ public static void bool4x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x2_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool4x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x2_operator_not_equal_wide_wide()
         {
             bool4x2 a0 = bool4x2(true, true, true, false, false, true, false, false);
@@ -111,7 +111,7 @@ public static void bool4x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x2_operator_not_equal_wide_scalar()
         {
             bool4x2 a0 = bool4x2(false, true, false, true, true, false, false, false);
@@ -135,7 +135,7 @@ public static void bool4x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x2_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool4x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x2_operator_bitwise_and_wide_wide()
         {
             bool4x2 a0 = bool4x2(false, false, true, true, false, false, true, true);
@@ -183,7 +183,7 @@ public static void bool4x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x2_operator_bitwise_and_wide_scalar()
         {
             bool4x2 a0 = bool4x2(true, false, false, true, true, false, false, false);
@@ -207,7 +207,7 @@ public static void bool4x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x2_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool4x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x2_operator_bitwise_or_wide_wide()
         {
             bool4x2 a0 = bool4x2(true, true, true, false, true, false, true, true);
@@ -255,7 +255,7 @@ public static void bool4x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x2_operator_bitwise_or_wide_scalar()
         {
             bool4x2 a0 = bool4x2(true, true, false, true, true, true, true, false);
@@ -279,7 +279,7 @@ public static void bool4x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x2_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool4x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x2_operator_bitwise_xor_wide_wide()
         {
             bool4x2 a0 = bool4x2(true, false, false, true, false, false, false, true);
@@ -327,7 +327,7 @@ public static void bool4x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x2_operator_bitwise_xor_wide_scalar()
         {
             bool4x2 a0 = bool4x2(false, false, true, true, false, false, false, false);
@@ -351,7 +351,7 @@ public static void bool4x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x2_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool4x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x2_operator_logical_not()
         {
             bool4x2 a0 = bool4x2(true, true, false, false, true, false, true, false);
diff --git a/src/Tests/Tests/Shared/TestBool4x3.gen.cs b/src/Tests/Tests/Shared/TestBool4x3.gen.cs
index 012ad7e5..ea0d9fe2 100644
--- a/src/Tests/Tests/Shared/TestBool4x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool4x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool4x3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x3_operator_equal_wide_wide()
         {
             bool4x3 a0 = bool4x3(true, false, true, false, false, true, false, false, true, false, true, false);
@@ -39,7 +39,7 @@ public static void bool4x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x3_operator_equal_wide_scalar()
         {
             bool4x3 a0 = bool4x3(false, true, false, false, false, false, true, false, false, false, true, true);
@@ -63,7 +63,7 @@ public static void bool4x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x3_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool4x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x3_operator_not_equal_wide_wide()
         {
             bool4x3 a0 = bool4x3(true, true, true, false, false, true, false, false, false, false, true, true);
@@ -111,7 +111,7 @@ public static void bool4x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x3_operator_not_equal_wide_scalar()
         {
             bool4x3 a0 = bool4x3(false, true, false, true, true, false, false, false, false, false, false, false);
@@ -135,7 +135,7 @@ public static void bool4x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x3_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool4x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x3_operator_bitwise_and_wide_wide()
         {
             bool4x3 a0 = bool4x3(false, false, true, true, false, false, true, true, true, false, true, true);
@@ -183,7 +183,7 @@ public static void bool4x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x3_operator_bitwise_and_wide_scalar()
         {
             bool4x3 a0 = bool4x3(true, false, false, true, true, false, false, false, false, false, true, true);
@@ -207,7 +207,7 @@ public static void bool4x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x3_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool4x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x3_operator_bitwise_or_wide_wide()
         {
             bool4x3 a0 = bool4x3(true, true, true, false, true, false, true, true, false, true, true, true);
@@ -255,7 +255,7 @@ public static void bool4x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x3_operator_bitwise_or_wide_scalar()
         {
             bool4x3 a0 = bool4x3(true, true, false, true, true, true, true, false, true, false, false, true);
@@ -279,7 +279,7 @@ public static void bool4x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x3_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool4x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x3_operator_bitwise_xor_wide_wide()
         {
             bool4x3 a0 = bool4x3(true, false, false, true, false, false, false, true, false, false, true, true);
@@ -327,7 +327,7 @@ public static void bool4x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x3_operator_bitwise_xor_wide_scalar()
         {
             bool4x3 a0 = bool4x3(false, false, true, true, false, false, false, false, false, false, false, true);
@@ -351,7 +351,7 @@ public static void bool4x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x3_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool4x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x3_operator_logical_not()
         {
             bool4x3 a0 = bool4x3(true, true, false, false, true, false, true, false, true, false, false, false);
diff --git a/src/Tests/Tests/Shared/TestBool4x4.gen.cs b/src/Tests/Tests/Shared/TestBool4x4.gen.cs
index 9cb7e412..11b5e424 100644
--- a/src/Tests/Tests/Shared/TestBool4x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestBool4x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestBool4x4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x4_operator_equal_wide_wide()
         {
             bool4x4 a0 = bool4x4(true, false, true, false, false, true, false, false, true, false, true, false, true, true, false, true);
@@ -39,7 +39,7 @@ public static void bool4x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x4_operator_equal_wide_scalar()
         {
             bool4x4 a0 = bool4x4(false, true, false, false, false, false, true, false, false, false, true, true, false, true, false, true);
@@ -63,7 +63,7 @@ public static void bool4x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x4_operator_equal_scalar_wide()
         {
             bool a0 = (false);
@@ -87,7 +87,7 @@ public static void bool4x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x4_operator_not_equal_wide_wide()
         {
             bool4x4 a0 = bool4x4(true, true, true, false, false, true, false, false, false, false, true, true, true, true, true, true);
@@ -111,7 +111,7 @@ public static void bool4x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x4_operator_not_equal_wide_scalar()
         {
             bool4x4 a0 = bool4x4(false, true, false, true, true, false, false, false, false, false, false, false, false, true, false, false);
@@ -135,7 +135,7 @@ public static void bool4x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x4_operator_not_equal_scalar_wide()
         {
             bool a0 = (true);
@@ -159,7 +159,7 @@ public static void bool4x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x4_operator_bitwise_and_wide_wide()
         {
             bool4x4 a0 = bool4x4(false, false, true, true, false, false, true, true, true, false, true, true, true, true, false, false);
@@ -183,7 +183,7 @@ public static void bool4x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x4_operator_bitwise_and_wide_scalar()
         {
             bool4x4 a0 = bool4x4(true, false, false, true, true, false, false, false, false, false, true, true, true, false, false, true);
@@ -207,7 +207,7 @@ public static void bool4x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x4_operator_bitwise_and_scalar_wide()
         {
             bool a0 = (false);
@@ -231,7 +231,7 @@ public static void bool4x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x4_operator_bitwise_or_wide_wide()
         {
             bool4x4 a0 = bool4x4(true, true, true, false, true, false, true, true, false, true, true, true, true, true, true, false);
@@ -255,7 +255,7 @@ public static void bool4x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x4_operator_bitwise_or_wide_scalar()
         {
             bool4x4 a0 = bool4x4(true, true, false, true, true, true, true, false, true, false, false, true, false, false, true, false);
@@ -279,7 +279,7 @@ public static void bool4x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x4_operator_bitwise_or_scalar_wide()
         {
             bool a0 = (true);
@@ -303,7 +303,7 @@ public static void bool4x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x4_operator_bitwise_xor_wide_wide()
         {
             bool4x4 a0 = bool4x4(true, false, false, true, false, false, false, true, false, false, true, true, false, false, true, false);
@@ -327,7 +327,7 @@ public static void bool4x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x4_operator_bitwise_xor_wide_scalar()
         {
             bool4x4 a0 = bool4x4(false, false, true, true, false, false, false, false, false, false, false, true, false, true, true, true);
@@ -351,7 +351,7 @@ public static void bool4x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x4_operator_bitwise_xor_scalar_wide()
         {
             bool a0 = (true);
@@ -375,7 +375,7 @@ public static void bool4x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4x4_operator_logical_not()
         {
             bool4x4 a0 = bool4x4(true, true, false, false, true, false, true, false, true, false, false, false, false, true, true, false);
diff --git a/src/Tests/Tests/Shared/TestDouble2.gen.cs b/src/Tests/Tests/Shared/TestDouble2.gen.cs
index 30a3f849..f07b51f5 100644
--- a/src/Tests/Tests/Shared/TestDouble2.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble2.gen.cs
@@ -15,14 +15,14 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_zero()
         {
             TestUtils.AreEqual(0.0, double2.zero.x);
             TestUtils.AreEqual(0.0, double2.zero.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_constructor()
         {
             double2 a = new double2(1, 2);
@@ -30,7 +30,7 @@ public static void double2_constructor()
             TestUtils.AreEqual(2, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_scalar_constructor()
         {
             double2 a = new double2(17.0);
@@ -38,7 +38,7 @@ public static void double2_scalar_constructor()
             TestUtils.AreEqual(17.0, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_static_constructor()
         {
             double2 a = double2(1, 2);
@@ -46,7 +46,7 @@ public static void double2_static_constructor()
             TestUtils.AreEqual(2, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_static_scalar_constructor()
         {
             double2 a = double2(17.0);
@@ -54,7 +54,7 @@ public static void double2_static_scalar_constructor()
             TestUtils.AreEqual(17.0, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_equal_wide_wide()
         {
             double2 a0 = double2(492.15758275061728, -495.20632027797694);
@@ -78,7 +78,7 @@ public static void double2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_equal_wide_scalar()
         {
             double2 a0 = double2(-303.2300766926399, 451.52631327674089);
@@ -102,7 +102,7 @@ public static void double2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -126,7 +126,7 @@ public static void double2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_not_equal_wide_wide()
         {
             double2 a0 = double2(430.8425316432689, 104.69001798736394);
@@ -150,7 +150,7 @@ public static void double2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_not_equal_wide_scalar()
         {
             double2 a0 = double2(-16.914588697680529, 168.83411486858233);
@@ -174,7 +174,7 @@ public static void double2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -198,7 +198,7 @@ public static void double2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_less_wide_wide()
         {
             double2 a0 = double2(196.84256825076534, 336.40979997087732);
@@ -222,7 +222,7 @@ public static void double2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_less_wide_scalar()
         {
             double2 a0 = double2(-132.05731708000292, -192.46500477216438);
@@ -246,7 +246,7 @@ public static void double2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -270,7 +270,7 @@ public static void double2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_greater_wide_wide()
         {
             double2 a0 = double2(483.50140141113729, 310.81563415695712);
@@ -294,7 +294,7 @@ public static void double2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_greater_wide_scalar()
         {
             double2 a0 = double2(64.317918092160426, -397.70346445483318);
@@ -318,7 +318,7 @@ public static void double2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -342,7 +342,7 @@ public static void double2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_less_equal_wide_wide()
         {
             double2 a0 = double2(-438.52313753521219, 210.48942837980087);
@@ -366,7 +366,7 @@ public static void double2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_less_equal_wide_scalar()
         {
             double2 a0 = double2(193.4958237118534, 168.91555197952107);
@@ -390,7 +390,7 @@ public static void double2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -414,7 +414,7 @@ public static void double2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_greater_equal_wide_wide()
         {
             double2 a0 = double2(-507.92858409692, 504.49748181947393);
@@ -438,7 +438,7 @@ public static void double2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_greater_equal_wide_scalar()
         {
             double2 a0 = double2(465.15218732559686, -424.8860745024337);
@@ -462,7 +462,7 @@ public static void double2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -486,7 +486,7 @@ public static void double2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_add_wide_wide()
         {
             double2 a0 = double2(506.12905263627374, -501.77980803967444);
@@ -510,7 +510,7 @@ public static void double2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_add_wide_scalar()
         {
             double2 a0 = double2(-194.51420387742769, 338.54838696985894);
@@ -534,7 +534,7 @@ public static void double2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -558,7 +558,7 @@ public static void double2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_sub_wide_wide()
         {
             double2 a0 = double2(160.4922617229131, 11.223957305412682);
@@ -582,7 +582,7 @@ public static void double2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_sub_wide_scalar()
         {
             double2 a0 = double2(207.38960108877609, 248.45773684627272);
@@ -606,7 +606,7 @@ public static void double2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -630,7 +630,7 @@ public static void double2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_mul_wide_wide()
         {
             double2 a0 = double2(-482.71381710596097, -407.29348559272171);
@@ -654,7 +654,7 @@ public static void double2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_mul_wide_scalar()
         {
             double2 a0 = double2(-96.318821236639678, -277.14229239017811);
@@ -678,7 +678,7 @@ public static void double2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -702,7 +702,7 @@ public static void double2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_div_wide_wide()
         {
             double2 a0 = double2(-353.13144390337703, -102.79985456485292);
@@ -726,7 +726,7 @@ public static void double2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_div_wide_scalar()
         {
             double2 a0 = double2(171.34242184988341, 0.10338377957384637);
@@ -750,7 +750,7 @@ public static void double2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -774,7 +774,7 @@ public static void double2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_mod_wide_wide()
         {
             double2 a0 = double2(-388.81249422059045, 181.68118842955732);
@@ -798,7 +798,7 @@ public static void double2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_mod_wide_scalar()
         {
             double2 a0 = double2(-244.49962889612635, -211.81931958525411);
@@ -822,7 +822,7 @@ public static void double2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -846,7 +846,7 @@ public static void double2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_plus()
         {
             double2 a0 = double2(-418.82956357432045, -405.79894823851015);
@@ -866,7 +866,7 @@ public static void double2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_neg()
         {
             double2 a0 = double2(148.46174890755753, -467.12267873581624);
@@ -886,7 +886,7 @@ public static void double2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_prefix_inc()
         {
             double2 a0 = double2(-139.84208137348389, -56.743654039103376);
@@ -906,7 +906,7 @@ public static void double2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_postfix_inc()
         {
             double2 a0 = double2(-396.6697396695007, 511.20749378167443);
@@ -926,7 +926,7 @@ public static void double2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_prefix_dec()
         {
             double2 a0 = double2(123.12869626056806, 256.8437465433235);
@@ -946,7 +946,7 @@ public static void double2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_operator_postfix_dec()
         {
             double2 a0 = double2(379.68831723727669, 302.69287814884115);
@@ -966,7 +966,7 @@ public static void double2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_shuffle_result_1()
         {
             double2 a = double2(0, 1);
@@ -978,7 +978,7 @@ public static void double2_shuffle_result_1()
             TestUtils.AreEqual((3), shuffle(a, b, ShuffleComponent.RightY));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_shuffle_result_2()
         {
             double2 a = double2(0, 1);
@@ -1002,7 +1002,7 @@ public static void double2_shuffle_result_2()
             TestUtils.AreEqual(double2(3, 3), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_shuffle_result_3()
         {
             double2 a = double2(0, 1);
@@ -1026,7 +1026,7 @@ public static void double2_shuffle_result_3()
             TestUtils.AreEqual(double3(3, 1, 1), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_shuffle_result_4()
         {
             double2 a = double2(0, 1);
diff --git a/src/Tests/Tests/Shared/TestDouble2x2.gen.cs b/src/Tests/Tests/Shared/TestDouble2x2.gen.cs
index 5531de5f..5b035267 100644
--- a/src/Tests/Tests/Shared/TestDouble2x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble2x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble2x2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_zero()
         {
             TestUtils.AreEqual(0.0, double2x2.zero.c0.x);
@@ -24,7 +24,7 @@ public static void double2x2_zero()
             TestUtils.AreEqual(0.0, double2x2.zero.c1.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_identity()
         {
             TestUtils.AreEqual(1.0, double2x2.identity.c0.x);
@@ -33,7 +33,7 @@ public static void double2x2_identity()
             TestUtils.AreEqual(1.0, double2x2.identity.c1.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_equal_wide_wide()
         {
             double2x2 a0 = double2x2(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182);
@@ -57,7 +57,7 @@ public static void double2x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_equal_wide_scalar()
         {
             double2x2 a0 = double2x2(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995);
@@ -81,7 +81,7 @@ public static void double2x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -105,7 +105,7 @@ public static void double2x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_not_equal_wide_wide()
         {
             double2x2 a0 = double2x2(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048);
@@ -129,7 +129,7 @@ public static void double2x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_not_equal_wide_scalar()
         {
             double2x2 a0 = double2x2(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137);
@@ -153,7 +153,7 @@ public static void double2x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -177,7 +177,7 @@ public static void double2x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_less_wide_wide()
         {
             double2x2 a0 = double2x2(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963);
@@ -201,7 +201,7 @@ public static void double2x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_less_wide_scalar()
         {
             double2x2 a0 = double2x2(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561);
@@ -225,7 +225,7 @@ public static void double2x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -249,7 +249,7 @@ public static void double2x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_greater_wide_wide()
         {
             double2x2 a0 = double2x2(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671);
@@ -273,7 +273,7 @@ public static void double2x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_greater_wide_scalar()
         {
             double2x2 a0 = double2x2(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157);
@@ -297,7 +297,7 @@ public static void double2x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -321,7 +321,7 @@ public static void double2x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_less_equal_wide_wide()
         {
             double2x2 a0 = double2x2(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857);
@@ -345,7 +345,7 @@ public static void double2x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_less_equal_wide_scalar()
         {
             double2x2 a0 = double2x2(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292);
@@ -369,7 +369,7 @@ public static void double2x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -393,7 +393,7 @@ public static void double2x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_greater_equal_wide_wide()
         {
             double2x2 a0 = double2x2(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784);
@@ -417,7 +417,7 @@ public static void double2x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_greater_equal_wide_scalar()
         {
             double2x2 a0 = double2x2(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356);
@@ -441,7 +441,7 @@ public static void double2x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -465,7 +465,7 @@ public static void double2x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_add_wide_wide()
         {
             double2x2 a0 = double2x2(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274);
@@ -489,7 +489,7 @@ public static void double2x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_add_wide_scalar()
         {
             double2x2 a0 = double2x2(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752);
@@ -513,7 +513,7 @@ public static void double2x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -537,7 +537,7 @@ public static void double2x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_sub_wide_wide()
         {
             double2x2 a0 = double2x2(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311);
@@ -561,7 +561,7 @@ public static void double2x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_sub_wide_scalar()
         {
             double2x2 a0 = double2x2(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506);
@@ -585,7 +585,7 @@ public static void double2x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -609,7 +609,7 @@ public static void double2x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_mul_wide_wide()
         {
             double2x2 a0 = double2x2(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182);
@@ -633,7 +633,7 @@ public static void double2x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_mul_wide_scalar()
         {
             double2x2 a0 = double2x2(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409);
@@ -657,7 +657,7 @@ public static void double2x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -681,7 +681,7 @@ public static void double2x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_div_wide_wide()
         {
             double2x2 a0 = double2x2(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176);
@@ -705,7 +705,7 @@ public static void double2x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_div_wide_scalar()
         {
             double2x2 a0 = double2x2(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078);
@@ -729,7 +729,7 @@ public static void double2x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -753,7 +753,7 @@ public static void double2x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_mod_wide_wide()
         {
             double2x2 a0 = double2x2(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813);
@@ -777,7 +777,7 @@ public static void double2x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_mod_wide_scalar()
         {
             double2x2 a0 = double2x2(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672);
@@ -801,7 +801,7 @@ public static void double2x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -825,7 +825,7 @@ public static void double2x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_plus()
         {
             double2x2 a0 = double2x2(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421);
@@ -845,7 +845,7 @@ public static void double2x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_neg()
         {
             double2x2 a0 = double2x2(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463);
@@ -865,7 +865,7 @@ public static void double2x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_prefix_inc()
         {
             double2x2 a0 = double2x2(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962);
@@ -885,7 +885,7 @@ public static void double2x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_postfix_inc()
         {
             double2x2 a0 = double2x2(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153);
@@ -905,7 +905,7 @@ public static void double2x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_prefix_dec()
         {
             double2x2 a0 = double2x2(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563);
@@ -925,7 +925,7 @@ public static void double2x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x2_operator_postfix_dec()
         {
             double2x2 a0 = double2x2(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962);
diff --git a/src/Tests/Tests/Shared/TestDouble2x3.gen.cs b/src/Tests/Tests/Shared/TestDouble2x3.gen.cs
index 20df3853..0b5cb5cf 100644
--- a/src/Tests/Tests/Shared/TestDouble2x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble2x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble2x3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_zero()
         {
             TestUtils.AreEqual(0.0, double2x3.zero.c0.x);
@@ -26,7 +26,7 @@ public static void double2x3_zero()
             TestUtils.AreEqual(0.0, double2x3.zero.c2.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_equal_wide_wide()
         {
             double2x3 a0 = double2x3(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749);
@@ -50,7 +50,7 @@ public static void double2x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_equal_wide_scalar()
         {
             double2x3 a0 = double2x3(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315);
@@ -74,7 +74,7 @@ public static void double2x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -98,7 +98,7 @@ public static void double2x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_not_equal_wide_wide()
         {
             double2x3 a0 = double2x3(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379);
@@ -122,7 +122,7 @@ public static void double2x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_not_equal_wide_scalar()
         {
             double2x3 a0 = double2x3(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959);
@@ -146,7 +146,7 @@ public static void double2x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -170,7 +170,7 @@ public static void double2x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_less_wide_wide()
         {
             double2x3 a0 = double2x3(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774);
@@ -194,7 +194,7 @@ public static void double2x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_less_wide_scalar()
         {
             double2x3 a0 = double2x3(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879);
@@ -218,7 +218,7 @@ public static void double2x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -242,7 +242,7 @@ public static void double2x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_greater_wide_wide()
         {
             double2x3 a0 = double2x3(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479);
@@ -266,7 +266,7 @@ public static void double2x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_greater_wide_scalar()
         {
             double2x3 a0 = double2x3(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809);
@@ -290,7 +290,7 @@ public static void double2x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -314,7 +314,7 @@ public static void double2x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_less_equal_wide_wide()
         {
             double2x3 a0 = double2x3(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475);
@@ -338,7 +338,7 @@ public static void double2x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_less_equal_wide_scalar()
         {
             double2x3 a0 = double2x3(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136);
@@ -362,7 +362,7 @@ public static void double2x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -386,7 +386,7 @@ public static void double2x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_greater_equal_wide_wide()
         {
             double2x3 a0 = double2x3(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193);
@@ -410,7 +410,7 @@ public static void double2x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_greater_equal_wide_scalar()
         {
             double2x3 a0 = double2x3(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976);
@@ -434,7 +434,7 @@ public static void double2x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -458,7 +458,7 @@ public static void double2x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_add_wide_wide()
         {
             double2x3 a0 = double2x3(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056);
@@ -482,7 +482,7 @@ public static void double2x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_add_wide_scalar()
         {
             double2x3 a0 = double2x3(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166);
@@ -506,7 +506,7 @@ public static void double2x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -530,7 +530,7 @@ public static void double2x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_sub_wide_wide()
         {
             double2x3 a0 = double2x3(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053);
@@ -554,7 +554,7 @@ public static void double2x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_sub_wide_scalar()
         {
             double2x3 a0 = double2x3(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896);
@@ -578,7 +578,7 @@ public static void double2x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -602,7 +602,7 @@ public static void double2x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_mul_wide_wide()
         {
             double2x3 a0 = double2x3(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747);
@@ -626,7 +626,7 @@ public static void double2x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_mul_wide_scalar()
         {
             double2x3 a0 = double2x3(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229);
@@ -650,7 +650,7 @@ public static void double2x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -674,7 +674,7 @@ public static void double2x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_div_wide_wide()
         {
             double2x3 a0 = double2x3(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758);
@@ -698,7 +698,7 @@ public static void double2x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_div_wide_scalar()
         {
             double2x3 a0 = double2x3(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509);
@@ -722,7 +722,7 @@ public static void double2x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -746,7 +746,7 @@ public static void double2x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_mod_wide_wide()
         {
             double2x3 a0 = double2x3(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406);
@@ -770,7 +770,7 @@ public static void double2x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_mod_wide_scalar()
         {
             double2x3 a0 = double2x3(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221);
@@ -794,7 +794,7 @@ public static void double2x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -818,7 +818,7 @@ public static void double2x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_plus()
         {
             double2x3 a0 = double2x3(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287);
@@ -838,7 +838,7 @@ public static void double2x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_neg()
         {
             double2x3 a0 = double2x3(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605);
@@ -858,7 +858,7 @@ public static void double2x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_prefix_inc()
         {
             double2x3 a0 = double2x3(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198);
@@ -878,7 +878,7 @@ public static void double2x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_postfix_inc()
         {
             double2x3 a0 = double2x3(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219);
@@ -898,7 +898,7 @@ public static void double2x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_prefix_dec()
         {
             double2x3 a0 = double2x3(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339);
@@ -918,7 +918,7 @@ public static void double2x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x3_operator_postfix_dec()
         {
             double2x3 a0 = double2x3(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231);
diff --git a/src/Tests/Tests/Shared/TestDouble2x4.gen.cs b/src/Tests/Tests/Shared/TestDouble2x4.gen.cs
index 822a43bb..c519d6f4 100644
--- a/src/Tests/Tests/Shared/TestDouble2x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble2x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble2x4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_zero()
         {
             TestUtils.AreEqual(0.0, double2x4.zero.c0.x);
@@ -28,7 +28,7 @@ public static void double2x4_zero()
             TestUtils.AreEqual(0.0, double2x4.zero.c3.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_equal_wide_wide()
         {
             double2x4 a0 = double2x4(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889);
@@ -52,7 +52,7 @@ public static void double2x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_equal_wide_scalar()
         {
             double2x4 a0 = double2x4(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405);
@@ -76,7 +76,7 @@ public static void double2x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -100,7 +100,7 @@ public static void double2x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_not_equal_wide_wide()
         {
             double2x4 a0 = double2x4(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895);
@@ -124,7 +124,7 @@ public static void double2x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_not_equal_wide_scalar()
         {
             double2x4 a0 = double2x4(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842);
@@ -148,7 +148,7 @@ public static void double2x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -172,7 +172,7 @@ public static void double2x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_less_wide_wide()
         {
             double2x4 a0 = double2x4(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259);
@@ -196,7 +196,7 @@ public static void double2x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_less_wide_scalar()
         {
             double2x4 a0 = double2x4(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061);
@@ -220,7 +220,7 @@ public static void double2x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -244,7 +244,7 @@ public static void double2x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_greater_wide_wide()
         {
             double2x4 a0 = double2x4(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484);
@@ -268,7 +268,7 @@ public static void double2x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_greater_wide_scalar()
         {
             double2x4 a0 = double2x4(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972);
@@ -292,7 +292,7 @@ public static void double2x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -316,7 +316,7 @@ public static void double2x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_less_equal_wide_wide()
         {
             double2x4 a0 = double2x4(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232);
@@ -340,7 +340,7 @@ public static void double2x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_less_equal_wide_scalar()
         {
             double2x4 a0 = double2x4(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582);
@@ -364,7 +364,7 @@ public static void double2x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -388,7 +388,7 @@ public static void double2x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_greater_equal_wide_wide()
         {
             double2x4 a0 = double2x4(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265);
@@ -412,7 +412,7 @@ public static void double2x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_greater_equal_wide_scalar()
         {
             double2x4 a0 = double2x4(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838);
@@ -436,7 +436,7 @@ public static void double2x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -460,7 +460,7 @@ public static void double2x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_add_wide_wide()
         {
             double2x4 a0 = double2x4(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656);
@@ -484,7 +484,7 @@ public static void double2x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_add_wide_scalar()
         {
             double2x4 a0 = double2x4(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454);
@@ -508,7 +508,7 @@ public static void double2x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -532,7 +532,7 @@ public static void double2x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_sub_wide_wide()
         {
             double2x4 a0 = double2x4(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537);
@@ -556,7 +556,7 @@ public static void double2x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_sub_wide_scalar()
         {
             double2x4 a0 = double2x4(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965);
@@ -580,7 +580,7 @@ public static void double2x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -604,7 +604,7 @@ public static void double2x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_mul_wide_wide()
         {
             double2x4 a0 = double2x4(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149);
@@ -628,7 +628,7 @@ public static void double2x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_mul_wide_scalar()
         {
             double2x4 a0 = double2x4(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334);
@@ -652,7 +652,7 @@ public static void double2x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -676,7 +676,7 @@ public static void double2x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_div_wide_wide()
         {
             double2x4 a0 = double2x4(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537);
@@ -700,7 +700,7 @@ public static void double2x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_div_wide_scalar()
         {
             double2x4 a0 = double2x4(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539);
@@ -724,7 +724,7 @@ public static void double2x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -748,7 +748,7 @@ public static void double2x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_mod_wide_wide()
         {
             double2x4 a0 = double2x4(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664);
@@ -772,7 +772,7 @@ public static void double2x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_mod_wide_scalar()
         {
             double2x4 a0 = double2x4(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243);
@@ -796,7 +796,7 @@ public static void double2x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -820,7 +820,7 @@ public static void double2x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_plus()
         {
             double2x4 a0 = double2x4(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488);
@@ -840,7 +840,7 @@ public static void double2x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_neg()
         {
             double2x4 a0 = double2x4(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581);
@@ -860,7 +860,7 @@ public static void double2x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_prefix_inc()
         {
             double2x4 a0 = double2x4(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267);
@@ -880,7 +880,7 @@ public static void double2x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_postfix_inc()
         {
             double2x4 a0 = double2x4(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271);
@@ -900,7 +900,7 @@ public static void double2x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_prefix_dec()
         {
             double2x4 a0 = double2x4(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558);
@@ -920,7 +920,7 @@ public static void double2x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2x4_operator_postfix_dec()
         {
             double2x4 a0 = double2x4(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568);
diff --git a/src/Tests/Tests/Shared/TestDouble3.gen.cs b/src/Tests/Tests/Shared/TestDouble3.gen.cs
index 2bd08a5d..59b1478b 100644
--- a/src/Tests/Tests/Shared/TestDouble3.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_zero()
         {
             TestUtils.AreEqual(0.0, double3.zero.x);
@@ -23,7 +23,7 @@ public static void double3_zero()
             TestUtils.AreEqual(0.0, double3.zero.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_constructor()
         {
             double3 a = new double3(1, 2, 3);
@@ -32,7 +32,7 @@ public static void double3_constructor()
             TestUtils.AreEqual(3, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_scalar_constructor()
         {
             double3 a = new double3(17.0);
@@ -41,7 +41,7 @@ public static void double3_scalar_constructor()
             TestUtils.AreEqual(17.0, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_static_constructor()
         {
             double3 a = double3(1, 2, 3);
@@ -50,7 +50,7 @@ public static void double3_static_constructor()
             TestUtils.AreEqual(3, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_static_scalar_constructor()
         {
             double3 a = double3(17.0);
@@ -59,7 +59,7 @@ public static void double3_static_scalar_constructor()
             TestUtils.AreEqual(17.0, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_equal_wide_wide()
         {
             double3 a0 = double3(492.15758275061728, -495.20632027797694, 227.45765195947968);
@@ -83,7 +83,7 @@ public static void double3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_equal_wide_scalar()
         {
             double3 a0 = double3(-303.2300766926399, 451.52631327674089, -253.65587413201848);
@@ -107,7 +107,7 @@ public static void double3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -131,7 +131,7 @@ public static void double3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_not_equal_wide_wide()
         {
             double3 a0 = double3(430.8425316432689, 104.69001798736394, 225.80243478799355);
@@ -155,7 +155,7 @@ public static void double3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_not_equal_wide_scalar()
         {
             double3 a0 = double3(-16.914588697680529, 168.83411486858233, -462.71352145760949);
@@ -179,7 +179,7 @@ public static void double3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -203,7 +203,7 @@ public static void double3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_less_wide_wide()
         {
             double3 a0 = double3(196.84256825076534, 336.40979997087732, 251.96372115424072);
@@ -227,7 +227,7 @@ public static void double3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_less_wide_scalar()
         {
             double3 a0 = double3(-132.05731708000292, -192.46500477216438, -66.834607870706634);
@@ -251,7 +251,7 @@ public static void double3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -275,7 +275,7 @@ public static void double3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_greater_wide_wide()
         {
             double3 a0 = double3(483.50140141113729, 310.81563415695712, 106.9661896726891);
@@ -299,7 +299,7 @@ public static void double3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_greater_wide_scalar()
         {
             double3 a0 = double3(64.317918092160426, -397.70346445483318, 431.87690826499693);
@@ -323,7 +323,7 @@ public static void double3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -347,7 +347,7 @@ public static void double3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_less_equal_wide_wide()
         {
             double3 a0 = double3(-438.52313753521219, 210.48942837980087, 4.8773329280677444);
@@ -371,7 +371,7 @@ public static void double3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_less_equal_wide_scalar()
         {
             double3 a0 = double3(193.4958237118534, 168.91555197952107, -313.9930695565385);
@@ -395,7 +395,7 @@ public static void double3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -419,7 +419,7 @@ public static void double3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_greater_equal_wide_wide()
         {
             double3 a0 = double3(-507.92858409692, 504.49748181947393, -385.43449205226938);
@@ -443,7 +443,7 @@ public static void double3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_greater_equal_wide_scalar()
         {
             double3 a0 = double3(465.15218732559686, -424.8860745024337, -209.22109685150025);
@@ -467,7 +467,7 @@ public static void double3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -491,7 +491,7 @@ public static void double3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_add_wide_wide()
         {
             double3 a0 = double3(506.12905263627374, -501.77980803967444, 420.08479638587903);
@@ -515,7 +515,7 @@ public static void double3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_add_wide_scalar()
         {
             double3 a0 = double3(-194.51420387742769, 338.54838696985894, 246.97140252169754);
@@ -539,7 +539,7 @@ public static void double3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -563,7 +563,7 @@ public static void double3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_sub_wide_wide()
         {
             double3 a0 = double3(160.4922617229131, 11.223957305412682, 359.20010607279846);
@@ -587,7 +587,7 @@ public static void double3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_sub_wide_scalar()
         {
             double3 a0 = double3(207.38960108877609, 248.45773684627272, -384.82393211164697);
@@ -611,7 +611,7 @@ public static void double3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -635,7 +635,7 @@ public static void double3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_mul_wide_wide()
         {
             double3 a0 = double3(-482.71381710596097, -407.29348559272171, 137.70058995937029);
@@ -659,7 +659,7 @@ public static void double3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_mul_wide_scalar()
         {
             double3 a0 = double3(-96.318821236639678, -277.14229239017811, -239.93690191951436);
@@ -683,7 +683,7 @@ public static void double3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -707,7 +707,7 @@ public static void double3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_div_wide_wide()
         {
             double3 a0 = double3(-353.13144390337703, -102.79985456485292, 51.319128298814917);
@@ -731,7 +731,7 @@ public static void double3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_div_wide_scalar()
         {
             double3 a0 = double3(171.34242184988341, 0.10338377957384637, 57.888263967767443);
@@ -755,7 +755,7 @@ public static void double3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -779,7 +779,7 @@ public static void double3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_mod_wide_wide()
         {
             double3 a0 = double3(-388.81249422059045, 181.68118842955732, -167.07872470052854);
@@ -803,7 +803,7 @@ public static void double3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_mod_wide_scalar()
         {
             double3 a0 = double3(-244.49962889612635, -211.81931958525411, -145.92677576184587);
@@ -827,7 +827,7 @@ public static void double3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -851,7 +851,7 @@ public static void double3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_plus()
         {
             double3 a0 = double3(-418.82956357432045, -405.79894823851015, -34.041791216489742);
@@ -871,7 +871,7 @@ public static void double3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_neg()
         {
             double3 a0 = double3(148.46174890755753, -467.12267873581624, 132.04719954917539);
@@ -891,7 +891,7 @@ public static void double3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_prefix_inc()
         {
             double3 a0 = double3(-139.84208137348389, -56.743654039103376, -381.955324589254);
@@ -911,7 +911,7 @@ public static void double3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_postfix_inc()
         {
             double3 a0 = double3(-396.6697396695007, 511.20749378167443, 249.11127030528678);
@@ -931,7 +931,7 @@ public static void double3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_prefix_dec()
         {
             double3 a0 = double3(123.12869626056806, 256.8437465433235, 156.33078844674435);
@@ -951,7 +951,7 @@ public static void double3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_operator_postfix_dec()
         {
             double3 a0 = double3(379.68831723727669, 302.69287814884115, -176.07134040448409);
@@ -971,7 +971,7 @@ public static void double3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_shuffle_result_1()
         {
             double3 a = double3(0, 1, 2);
@@ -985,7 +985,7 @@ public static void double3_shuffle_result_1()
             TestUtils.AreEqual((5), shuffle(a, b, ShuffleComponent.RightZ));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_shuffle_result_2()
         {
             double3 a = double3(0, 1, 2);
@@ -1009,7 +1009,7 @@ public static void double3_shuffle_result_2()
             TestUtils.AreEqual(double2(1, 2), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_shuffle_result_3()
         {
             double3 a = double3(0, 1, 2);
@@ -1033,7 +1033,7 @@ public static void double3_shuffle_result_3()
             TestUtils.AreEqual(double3(4, 0, 5), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_shuffle_result_4()
         {
             double3 a = double3(0, 1, 2);
diff --git a/src/Tests/Tests/Shared/TestDouble3x2.gen.cs b/src/Tests/Tests/Shared/TestDouble3x2.gen.cs
index bbfffa3a..0fd677a3 100644
--- a/src/Tests/Tests/Shared/TestDouble3x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble3x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble3x2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_zero()
         {
             TestUtils.AreEqual(0.0, double3x2.zero.c0.x);
@@ -26,7 +26,7 @@ public static void double3x2_zero()
             TestUtils.AreEqual(0.0, double3x2.zero.c1.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_equal_wide_wide()
         {
             double3x2 a0 = double3x2(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749);
@@ -50,7 +50,7 @@ public static void double3x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_equal_wide_scalar()
         {
             double3x2 a0 = double3x2(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315);
@@ -74,7 +74,7 @@ public static void double3x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -98,7 +98,7 @@ public static void double3x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_not_equal_wide_wide()
         {
             double3x2 a0 = double3x2(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379);
@@ -122,7 +122,7 @@ public static void double3x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_not_equal_wide_scalar()
         {
             double3x2 a0 = double3x2(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959);
@@ -146,7 +146,7 @@ public static void double3x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -170,7 +170,7 @@ public static void double3x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_less_wide_wide()
         {
             double3x2 a0 = double3x2(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774);
@@ -194,7 +194,7 @@ public static void double3x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_less_wide_scalar()
         {
             double3x2 a0 = double3x2(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879);
@@ -218,7 +218,7 @@ public static void double3x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -242,7 +242,7 @@ public static void double3x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_greater_wide_wide()
         {
             double3x2 a0 = double3x2(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479);
@@ -266,7 +266,7 @@ public static void double3x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_greater_wide_scalar()
         {
             double3x2 a0 = double3x2(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809);
@@ -290,7 +290,7 @@ public static void double3x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -314,7 +314,7 @@ public static void double3x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_less_equal_wide_wide()
         {
             double3x2 a0 = double3x2(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475);
@@ -338,7 +338,7 @@ public static void double3x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_less_equal_wide_scalar()
         {
             double3x2 a0 = double3x2(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136);
@@ -362,7 +362,7 @@ public static void double3x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -386,7 +386,7 @@ public static void double3x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_greater_equal_wide_wide()
         {
             double3x2 a0 = double3x2(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193);
@@ -410,7 +410,7 @@ public static void double3x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_greater_equal_wide_scalar()
         {
             double3x2 a0 = double3x2(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976);
@@ -434,7 +434,7 @@ public static void double3x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -458,7 +458,7 @@ public static void double3x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_add_wide_wide()
         {
             double3x2 a0 = double3x2(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056);
@@ -482,7 +482,7 @@ public static void double3x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_add_wide_scalar()
         {
             double3x2 a0 = double3x2(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166);
@@ -506,7 +506,7 @@ public static void double3x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -530,7 +530,7 @@ public static void double3x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_sub_wide_wide()
         {
             double3x2 a0 = double3x2(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053);
@@ -554,7 +554,7 @@ public static void double3x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_sub_wide_scalar()
         {
             double3x2 a0 = double3x2(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896);
@@ -578,7 +578,7 @@ public static void double3x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -602,7 +602,7 @@ public static void double3x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_mul_wide_wide()
         {
             double3x2 a0 = double3x2(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747);
@@ -626,7 +626,7 @@ public static void double3x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_mul_wide_scalar()
         {
             double3x2 a0 = double3x2(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229);
@@ -650,7 +650,7 @@ public static void double3x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -674,7 +674,7 @@ public static void double3x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_div_wide_wide()
         {
             double3x2 a0 = double3x2(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758);
@@ -698,7 +698,7 @@ public static void double3x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_div_wide_scalar()
         {
             double3x2 a0 = double3x2(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509);
@@ -722,7 +722,7 @@ public static void double3x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -746,7 +746,7 @@ public static void double3x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_mod_wide_wide()
         {
             double3x2 a0 = double3x2(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406);
@@ -770,7 +770,7 @@ public static void double3x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_mod_wide_scalar()
         {
             double3x2 a0 = double3x2(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221);
@@ -794,7 +794,7 @@ public static void double3x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -818,7 +818,7 @@ public static void double3x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_plus()
         {
             double3x2 a0 = double3x2(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287);
@@ -838,7 +838,7 @@ public static void double3x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_neg()
         {
             double3x2 a0 = double3x2(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605);
@@ -858,7 +858,7 @@ public static void double3x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_prefix_inc()
         {
             double3x2 a0 = double3x2(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198);
@@ -878,7 +878,7 @@ public static void double3x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_postfix_inc()
         {
             double3x2 a0 = double3x2(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219);
@@ -898,7 +898,7 @@ public static void double3x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_prefix_dec()
         {
             double3x2 a0 = double3x2(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339);
@@ -918,7 +918,7 @@ public static void double3x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x2_operator_postfix_dec()
         {
             double3x2 a0 = double3x2(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231);
diff --git a/src/Tests/Tests/Shared/TestDouble3x3.gen.cs b/src/Tests/Tests/Shared/TestDouble3x3.gen.cs
index aca1ba86..d066be3d 100644
--- a/src/Tests/Tests/Shared/TestDouble3x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble3x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble3x3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_zero()
         {
             TestUtils.AreEqual(0.0, double3x3.zero.c0.x);
@@ -29,7 +29,7 @@ public static void double3x3_zero()
             TestUtils.AreEqual(0.0, double3x3.zero.c2.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_identity()
         {
             TestUtils.AreEqual(1.0, double3x3.identity.c0.x);
@@ -43,7 +43,7 @@ public static void double3x3_identity()
             TestUtils.AreEqual(1.0, double3x3.identity.c2.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_equal_wide_wide()
         {
             double3x3 a0 = double3x3(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889, 163.23210890741655);
@@ -67,7 +67,7 @@ public static void double3x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_equal_wide_scalar()
         {
             double3x3 a0 = double3x3(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405, -57.477391031327386);
@@ -91,7 +91,7 @@ public static void double3x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -115,7 +115,7 @@ public static void double3x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_not_equal_wide_wide()
         {
             double3x3 a0 = double3x3(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895, -203.30197606016975);
@@ -139,7 +139,7 @@ public static void double3x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_not_equal_wide_scalar()
         {
             double3x3 a0 = double3x3(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842, -386.61117595555783);
@@ -163,7 +163,7 @@ public static void double3x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -187,7 +187,7 @@ public static void double3x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_less_wide_wide()
         {
             double3x3 a0 = double3x3(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259, 164.67880662003472);
@@ -211,7 +211,7 @@ public static void double3x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_less_wide_scalar()
         {
             double3x3 a0 = double3x3(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061, -20.452607402788772);
@@ -235,7 +235,7 @@ public static void double3x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -259,7 +259,7 @@ public static void double3x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_greater_wide_wide()
         {
             double3x3 a0 = double3x3(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484, -24.740548383789417);
@@ -283,7 +283,7 @@ public static void double3x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_greater_wide_scalar()
         {
             double3x3 a0 = double3x3(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972, -405.78459210218148);
@@ -307,7 +307,7 @@ public static void double3x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -331,7 +331,7 @@ public static void double3x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_less_equal_wide_wide()
         {
             double3x3 a0 = double3x3(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232, 458.53029153241323);
@@ -355,7 +355,7 @@ public static void double3x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_less_equal_wide_scalar()
         {
             double3x3 a0 = double3x3(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582, -1.3577692515020203);
@@ -379,7 +379,7 @@ public static void double3x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -403,7 +403,7 @@ public static void double3x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_greater_equal_wide_wide()
         {
             double3x3 a0 = double3x3(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265, 456.96878573716094);
@@ -427,7 +427,7 @@ public static void double3x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_greater_equal_wide_scalar()
         {
             double3x3 a0 = double3x3(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838, 393.27804846003562);
@@ -451,7 +451,7 @@ public static void double3x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -475,7 +475,7 @@ public static void double3x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_add_wide_wide()
         {
             double3x3 a0 = double3x3(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656, 462.41368148402012);
@@ -499,7 +499,7 @@ public static void double3x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_add_wide_scalar()
         {
             double3x3 a0 = double3x3(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454, -242.1187475855084);
@@ -523,7 +523,7 @@ public static void double3x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -547,7 +547,7 @@ public static void double3x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_sub_wide_wide()
         {
             double3x3 a0 = double3x3(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537, 317.70681944382693);
@@ -571,7 +571,7 @@ public static void double3x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_sub_wide_scalar()
         {
             double3x3 a0 = double3x3(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965, 480.85798738936796);
@@ -595,7 +595,7 @@ public static void double3x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -619,7 +619,7 @@ public static void double3x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_mul_wide_wide()
         {
             double3x3 a0 = double3x3(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149, 45.868758938214114);
@@ -643,7 +643,7 @@ public static void double3x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_mul_wide_scalar()
         {
             double3x3 a0 = double3x3(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334, -338.29248658674419);
@@ -667,7 +667,7 @@ public static void double3x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -691,7 +691,7 @@ public static void double3x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_div_wide_wide()
         {
             double3x3 a0 = double3x3(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537, -237.69456326109105);
@@ -715,7 +715,7 @@ public static void double3x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_div_wide_scalar()
         {
             double3x3 a0 = double3x3(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539, 146.46688110496234);
@@ -739,7 +739,7 @@ public static void double3x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -763,7 +763,7 @@ public static void double3x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_mod_wide_wide()
         {
             double3x3 a0 = double3x3(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664, 335.27101413126616);
@@ -787,7 +787,7 @@ public static void double3x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_mod_wide_scalar()
         {
             double3x3 a0 = double3x3(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243, 335.16613046041039);
@@ -811,7 +811,7 @@ public static void double3x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -835,7 +835,7 @@ public static void double3x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_plus()
         {
             double3x3 a0 = double3x3(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488, -386.059833944803);
@@ -855,7 +855,7 @@ public static void double3x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_neg()
         {
             double3x3 a0 = double3x3(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581, -299.09338893512887);
@@ -875,7 +875,7 @@ public static void double3x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_prefix_inc()
         {
             double3x3 a0 = double3x3(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267, 362.21273939787068);
@@ -895,7 +895,7 @@ public static void double3x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_postfix_inc()
         {
             double3x3 a0 = double3x3(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271, 167.85212691493894);
@@ -915,7 +915,7 @@ public static void double3x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_prefix_dec()
         {
             double3x3 a0 = double3x3(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558, 125.10963517292851);
@@ -935,7 +935,7 @@ public static void double3x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x3_operator_postfix_dec()
         {
             double3x3 a0 = double3x3(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568, -27.889220489137415);
diff --git a/src/Tests/Tests/Shared/TestDouble3x4.gen.cs b/src/Tests/Tests/Shared/TestDouble3x4.gen.cs
index 48170ecf..03ea5969 100644
--- a/src/Tests/Tests/Shared/TestDouble3x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble3x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble3x4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_zero()
         {
             TestUtils.AreEqual(0.0, double3x4.zero.c0.x);
@@ -32,7 +32,7 @@ public static void double3x4_zero()
             TestUtils.AreEqual(0.0, double3x4.zero.c3.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_equal_wide_wide()
         {
             double3x4 a0 = double3x4(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889, 163.23210890741655, -165.27101071424363, 470.87767980568003, -423.94255967808078);
@@ -56,7 +56,7 @@ public static void double3x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_equal_wide_scalar()
         {
             double3x4 a0 = double3x4(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405, -57.477391031327386, -182.04973968400139, 406.51375861024189, 370.88599866017978);
@@ -80,7 +80,7 @@ public static void double3x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -104,7 +104,7 @@ public static void double3x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_not_equal_wide_wide()
         {
             double3x4 a0 = double3x4(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895, -203.30197606016975, -505.76325368590807, 162.17220623892365, 1.1561973100324394);
@@ -128,7 +128,7 @@ public static void double3x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_not_equal_wide_scalar()
         {
             double3x4 a0 = double3x4(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842, -386.61117595555783, -281.02101362916687, -270.26885593601912, -403.96372313236992);
@@ -152,7 +152,7 @@ public static void double3x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -176,7 +176,7 @@ public static void double3x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_less_wide_wide()
         {
             double3x4 a0 = double3x4(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259, 164.67880662003472, -350.94487516532877, 3.84143662631584, 125.40972024081725);
@@ -200,7 +200,7 @@ public static void double3x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_less_wide_scalar()
         {
             double3x4 a0 = double3x4(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061, -20.452607402788772, 225.29148517609178, 307.48418607725023, 274.01523292903562);
@@ -224,7 +224,7 @@ public static void double3x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -248,7 +248,7 @@ public static void double3x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_greater_wide_wide()
         {
             double3x4 a0 = double3x4(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484, -24.740548383789417, 319.78262701620474, -120.15856581561201, -289.00857962714906);
@@ -272,7 +272,7 @@ public static void double3x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_greater_wide_scalar()
         {
             double3x4 a0 = double3x4(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972, -405.78459210218148, 171.56538661362856, -241.80727326209063, 333.57817498481745);
@@ -296,7 +296,7 @@ public static void double3x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -320,7 +320,7 @@ public static void double3x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_less_equal_wide_wide()
         {
             double3x4 a0 = double3x4(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232, 458.53029153241323, -294.06474675520542, 23.622613679441884, -34.284056441059363);
@@ -344,7 +344,7 @@ public static void double3x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_less_equal_wide_scalar()
         {
             double3x4 a0 = double3x4(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582, -1.3577692515020203, -268.89945591096739, 398.9919504593089, -471.253072242836);
@@ -368,7 +368,7 @@ public static void double3x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -392,7 +392,7 @@ public static void double3x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_greater_equal_wide_wide()
         {
             double3x4 a0 = double3x4(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265, 456.96878573716094, -211.01015506079892, 182.41135391146474, -53.596053863687473);
@@ -416,7 +416,7 @@ public static void double3x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_greater_equal_wide_scalar()
         {
             double3x4 a0 = double3x4(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838, 393.27804846003562, -315.70155086913218, 441.0115565923096, -509.78156757251435);
@@ -440,7 +440,7 @@ public static void double3x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -464,7 +464,7 @@ public static void double3x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_add_wide_wide()
         {
             double3x4 a0 = double3x4(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656, 462.41368148402012, -46.178705952213477, 401.17006296718966, -454.12414643453627);
@@ -488,7 +488,7 @@ public static void double3x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_add_wide_scalar()
         {
             double3x4 a0 = double3x4(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454, -242.1187475855084, 82.50134495762245, 6.7993848355483806, -484.69981287638649);
@@ -512,7 +512,7 @@ public static void double3x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -536,7 +536,7 @@ public static void double3x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_sub_wide_wide()
         {
             double3x4 a0 = double3x4(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537, 317.70681944382693, 447.0604133303558, -489.07414482956477, -230.00838218909149);
@@ -560,7 +560,7 @@ public static void double3x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_sub_wide_scalar()
         {
             double3x4 a0 = double3x4(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965, 480.85798738936796, 16.338193185784917, -366.86545269883493, -35.523088233323335);
@@ -584,7 +584,7 @@ public static void double3x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -608,7 +608,7 @@ public static void double3x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_mul_wide_wide()
         {
             double3x4 a0 = double3x4(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149, 45.868758938214114, 363.32610266438041, -328.11893692990714, -471.02307413100408);
@@ -632,7 +632,7 @@ public static void double3x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_mul_wide_scalar()
         {
             double3x4 a0 = double3x4(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334, -338.29248658674419, 53.796284939067618, 243.75734459783757, 135.35469991311186);
@@ -656,7 +656,7 @@ public static void double3x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -680,7 +680,7 @@ public static void double3x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_div_wide_wide()
         {
             double3x4 a0 = double3x4(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537, -237.69456326109105, -432.54687496300176, 200.26549181727012, 361.44157068871039);
@@ -704,7 +704,7 @@ public static void double3x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_div_wide_scalar()
         {
             double3x4 a0 = double3x4(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539, 146.46688110496234, -499.84355687529012, 58.686315802245531, -453.20579859856787);
@@ -728,7 +728,7 @@ public static void double3x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -752,7 +752,7 @@ public static void double3x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_mod_wide_wide()
         {
             double3x4 a0 = double3x4(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664, 335.27101413126616, -503.60851668920765, 191.02251848532933, 289.74269379756538);
@@ -776,7 +776,7 @@ public static void double3x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_mod_wide_scalar()
         {
             double3x4 a0 = double3x4(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243, 335.16613046041039, 101.70649032560482, 319.47152033423606, -285.40231646476423);
@@ -800,7 +800,7 @@ public static void double3x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -824,7 +824,7 @@ public static void double3x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_plus()
         {
             double3x4 a0 = double3x4(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488, -386.059833944803, 4.9544198536101476, -418.64524932328857, 504.47483062393724);
@@ -844,7 +844,7 @@ public static void double3x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_neg()
         {
             double3x4 a0 = double3x4(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581, -299.09338893512887, -383.01406377508027, 407.70980305583669, 168.73550351370852);
@@ -864,7 +864,7 @@ public static void double3x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_prefix_inc()
         {
             double3x4 a0 = double3x4(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267, 362.21273939787068, 401.614830919362, 130.90919429199266, -450.23016402229212);
@@ -884,7 +884,7 @@ public static void double3x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_postfix_inc()
         {
             double3x4 a0 = double3x4(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271, 167.85212691493894, 147.94395048354932, -326.10758486674524, 41.033564825092185);
@@ -904,7 +904,7 @@ public static void double3x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_prefix_dec()
         {
             double3x4 a0 = double3x4(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558, 125.10963517292851, 469.8447313112415, 45.536655685648611, 376.04684680329956);
@@ -924,7 +924,7 @@ public static void double3x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3x4_operator_postfix_dec()
         {
             double3x4 a0 = double3x4(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568, -27.889220489137415, -100.76183824462902, 156.14034969924967, 479.94519613680677);
diff --git a/src/Tests/Tests/Shared/TestDouble4.gen.cs b/src/Tests/Tests/Shared/TestDouble4.gen.cs
index 6dec9e23..0344dae9 100644
--- a/src/Tests/Tests/Shared/TestDouble4.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_zero()
         {
             TestUtils.AreEqual(0.0, double4.zero.x);
@@ -24,7 +24,7 @@ public static void double4_zero()
             TestUtils.AreEqual(0.0, double4.zero.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_constructor()
         {
             double4 a = new double4(1, 2, 3, 4);
@@ -34,7 +34,7 @@ public static void double4_constructor()
             TestUtils.AreEqual(4, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_scalar_constructor()
         {
             double4 a = new double4(17.0);
@@ -44,7 +44,7 @@ public static void double4_scalar_constructor()
             TestUtils.AreEqual(17.0, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_static_constructor()
         {
             double4 a = double4(1, 2, 3, 4);
@@ -54,7 +54,7 @@ public static void double4_static_constructor()
             TestUtils.AreEqual(4, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_static_scalar_constructor()
         {
             double4 a = double4(17.0);
@@ -64,7 +64,7 @@ public static void double4_static_scalar_constructor()
             TestUtils.AreEqual(17.0, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_equal_wide_wide()
         {
             double4 a0 = double4(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182);
@@ -88,7 +88,7 @@ public static void double4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_equal_wide_scalar()
         {
             double4 a0 = double4(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995);
@@ -112,7 +112,7 @@ public static void double4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -136,7 +136,7 @@ public static void double4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_not_equal_wide_wide()
         {
             double4 a0 = double4(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048);
@@ -160,7 +160,7 @@ public static void double4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_not_equal_wide_scalar()
         {
             double4 a0 = double4(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137);
@@ -184,7 +184,7 @@ public static void double4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -208,7 +208,7 @@ public static void double4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_less_wide_wide()
         {
             double4 a0 = double4(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963);
@@ -232,7 +232,7 @@ public static void double4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_less_wide_scalar()
         {
             double4 a0 = double4(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561);
@@ -256,7 +256,7 @@ public static void double4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -280,7 +280,7 @@ public static void double4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_greater_wide_wide()
         {
             double4 a0 = double4(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671);
@@ -304,7 +304,7 @@ public static void double4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_greater_wide_scalar()
         {
             double4 a0 = double4(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157);
@@ -328,7 +328,7 @@ public static void double4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -352,7 +352,7 @@ public static void double4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_less_equal_wide_wide()
         {
             double4 a0 = double4(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857);
@@ -376,7 +376,7 @@ public static void double4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_less_equal_wide_scalar()
         {
             double4 a0 = double4(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292);
@@ -400,7 +400,7 @@ public static void double4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -424,7 +424,7 @@ public static void double4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_greater_equal_wide_wide()
         {
             double4 a0 = double4(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784);
@@ -448,7 +448,7 @@ public static void double4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_greater_equal_wide_scalar()
         {
             double4 a0 = double4(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356);
@@ -472,7 +472,7 @@ public static void double4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -496,7 +496,7 @@ public static void double4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_add_wide_wide()
         {
             double4 a0 = double4(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274);
@@ -520,7 +520,7 @@ public static void double4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_add_wide_scalar()
         {
             double4 a0 = double4(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752);
@@ -544,7 +544,7 @@ public static void double4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -568,7 +568,7 @@ public static void double4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_sub_wide_wide()
         {
             double4 a0 = double4(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311);
@@ -592,7 +592,7 @@ public static void double4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_sub_wide_scalar()
         {
             double4 a0 = double4(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506);
@@ -616,7 +616,7 @@ public static void double4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -640,7 +640,7 @@ public static void double4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_mul_wide_wide()
         {
             double4 a0 = double4(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182);
@@ -664,7 +664,7 @@ public static void double4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_mul_wide_scalar()
         {
             double4 a0 = double4(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409);
@@ -688,7 +688,7 @@ public static void double4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -712,7 +712,7 @@ public static void double4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_div_wide_wide()
         {
             double4 a0 = double4(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176);
@@ -736,7 +736,7 @@ public static void double4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_div_wide_scalar()
         {
             double4 a0 = double4(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078);
@@ -760,7 +760,7 @@ public static void double4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -784,7 +784,7 @@ public static void double4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_mod_wide_wide()
         {
             double4 a0 = double4(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813);
@@ -808,7 +808,7 @@ public static void double4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_mod_wide_scalar()
         {
             double4 a0 = double4(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672);
@@ -832,7 +832,7 @@ public static void double4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -856,7 +856,7 @@ public static void double4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_plus()
         {
             double4 a0 = double4(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421);
@@ -876,7 +876,7 @@ public static void double4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_neg()
         {
             double4 a0 = double4(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463);
@@ -896,7 +896,7 @@ public static void double4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_prefix_inc()
         {
             double4 a0 = double4(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962);
@@ -916,7 +916,7 @@ public static void double4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_postfix_inc()
         {
             double4 a0 = double4(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153);
@@ -936,7 +936,7 @@ public static void double4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_prefix_dec()
         {
             double4 a0 = double4(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563);
@@ -956,7 +956,7 @@ public static void double4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_operator_postfix_dec()
         {
             double4 a0 = double4(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962);
@@ -976,7 +976,7 @@ public static void double4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_shuffle_result_1()
         {
             double4 a = double4(0, 1, 2, 3);
@@ -992,7 +992,7 @@ public static void double4_shuffle_result_1()
             TestUtils.AreEqual((7), shuffle(a, b, ShuffleComponent.RightW));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_shuffle_result_2()
         {
             double4 a = double4(0, 1, 2, 3);
@@ -1016,7 +1016,7 @@ public static void double4_shuffle_result_2()
             TestUtils.AreEqual(double2(1, 3), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_shuffle_result_3()
         {
             double4 a = double4(0, 1, 2, 3);
@@ -1040,7 +1040,7 @@ public static void double4_shuffle_result_3()
             TestUtils.AreEqual(double3(5, 1, 7), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_shuffle_result_4()
         {
             double4 a = double4(0, 1, 2, 3);
diff --git a/src/Tests/Tests/Shared/TestDouble4x2.gen.cs b/src/Tests/Tests/Shared/TestDouble4x2.gen.cs
index 112a10df..80b2e856 100644
--- a/src/Tests/Tests/Shared/TestDouble4x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble4x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble4x2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_zero()
         {
             TestUtils.AreEqual(0.0, double4x2.zero.c0.x);
@@ -28,7 +28,7 @@ public static void double4x2_zero()
             TestUtils.AreEqual(0.0, double4x2.zero.c1.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_equal_wide_wide()
         {
             double4x2 a0 = double4x2(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889);
@@ -52,7 +52,7 @@ public static void double4x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_equal_wide_scalar()
         {
             double4x2 a0 = double4x2(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405);
@@ -76,7 +76,7 @@ public static void double4x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -100,7 +100,7 @@ public static void double4x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_not_equal_wide_wide()
         {
             double4x2 a0 = double4x2(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895);
@@ -124,7 +124,7 @@ public static void double4x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_not_equal_wide_scalar()
         {
             double4x2 a0 = double4x2(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842);
@@ -148,7 +148,7 @@ public static void double4x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -172,7 +172,7 @@ public static void double4x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_less_wide_wide()
         {
             double4x2 a0 = double4x2(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259);
@@ -196,7 +196,7 @@ public static void double4x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_less_wide_scalar()
         {
             double4x2 a0 = double4x2(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061);
@@ -220,7 +220,7 @@ public static void double4x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -244,7 +244,7 @@ public static void double4x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_greater_wide_wide()
         {
             double4x2 a0 = double4x2(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484);
@@ -268,7 +268,7 @@ public static void double4x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_greater_wide_scalar()
         {
             double4x2 a0 = double4x2(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972);
@@ -292,7 +292,7 @@ public static void double4x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -316,7 +316,7 @@ public static void double4x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_less_equal_wide_wide()
         {
             double4x2 a0 = double4x2(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232);
@@ -340,7 +340,7 @@ public static void double4x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_less_equal_wide_scalar()
         {
             double4x2 a0 = double4x2(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582);
@@ -364,7 +364,7 @@ public static void double4x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -388,7 +388,7 @@ public static void double4x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_greater_equal_wide_wide()
         {
             double4x2 a0 = double4x2(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265);
@@ -412,7 +412,7 @@ public static void double4x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_greater_equal_wide_scalar()
         {
             double4x2 a0 = double4x2(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838);
@@ -436,7 +436,7 @@ public static void double4x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -460,7 +460,7 @@ public static void double4x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_add_wide_wide()
         {
             double4x2 a0 = double4x2(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656);
@@ -484,7 +484,7 @@ public static void double4x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_add_wide_scalar()
         {
             double4x2 a0 = double4x2(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454);
@@ -508,7 +508,7 @@ public static void double4x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -532,7 +532,7 @@ public static void double4x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_sub_wide_wide()
         {
             double4x2 a0 = double4x2(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537);
@@ -556,7 +556,7 @@ public static void double4x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_sub_wide_scalar()
         {
             double4x2 a0 = double4x2(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965);
@@ -580,7 +580,7 @@ public static void double4x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -604,7 +604,7 @@ public static void double4x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_mul_wide_wide()
         {
             double4x2 a0 = double4x2(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149);
@@ -628,7 +628,7 @@ public static void double4x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_mul_wide_scalar()
         {
             double4x2 a0 = double4x2(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334);
@@ -652,7 +652,7 @@ public static void double4x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -676,7 +676,7 @@ public static void double4x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_div_wide_wide()
         {
             double4x2 a0 = double4x2(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537);
@@ -700,7 +700,7 @@ public static void double4x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_div_wide_scalar()
         {
             double4x2 a0 = double4x2(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539);
@@ -724,7 +724,7 @@ public static void double4x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -748,7 +748,7 @@ public static void double4x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_mod_wide_wide()
         {
             double4x2 a0 = double4x2(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664);
@@ -772,7 +772,7 @@ public static void double4x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_mod_wide_scalar()
         {
             double4x2 a0 = double4x2(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243);
@@ -796,7 +796,7 @@ public static void double4x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -820,7 +820,7 @@ public static void double4x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_plus()
         {
             double4x2 a0 = double4x2(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488);
@@ -840,7 +840,7 @@ public static void double4x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_neg()
         {
             double4x2 a0 = double4x2(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581);
@@ -860,7 +860,7 @@ public static void double4x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_prefix_inc()
         {
             double4x2 a0 = double4x2(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267);
@@ -880,7 +880,7 @@ public static void double4x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_postfix_inc()
         {
             double4x2 a0 = double4x2(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271);
@@ -900,7 +900,7 @@ public static void double4x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_prefix_dec()
         {
             double4x2 a0 = double4x2(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558);
@@ -920,7 +920,7 @@ public static void double4x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x2_operator_postfix_dec()
         {
             double4x2 a0 = double4x2(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568);
diff --git a/src/Tests/Tests/Shared/TestDouble4x3.gen.cs b/src/Tests/Tests/Shared/TestDouble4x3.gen.cs
index 90982950..6debf3f6 100644
--- a/src/Tests/Tests/Shared/TestDouble4x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble4x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble4x3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_zero()
         {
             TestUtils.AreEqual(0.0, double4x3.zero.c0.x);
@@ -32,7 +32,7 @@ public static void double4x3_zero()
             TestUtils.AreEqual(0.0, double4x3.zero.c2.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_equal_wide_wide()
         {
             double4x3 a0 = double4x3(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889, 163.23210890741655, -165.27101071424363, 470.87767980568003, -423.94255967808078);
@@ -56,7 +56,7 @@ public static void double4x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_equal_wide_scalar()
         {
             double4x3 a0 = double4x3(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405, -57.477391031327386, -182.04973968400139, 406.51375861024189, 370.88599866017978);
@@ -80,7 +80,7 @@ public static void double4x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -104,7 +104,7 @@ public static void double4x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_not_equal_wide_wide()
         {
             double4x3 a0 = double4x3(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895, -203.30197606016975, -505.76325368590807, 162.17220623892365, 1.1561973100324394);
@@ -128,7 +128,7 @@ public static void double4x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_not_equal_wide_scalar()
         {
             double4x3 a0 = double4x3(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842, -386.61117595555783, -281.02101362916687, -270.26885593601912, -403.96372313236992);
@@ -152,7 +152,7 @@ public static void double4x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -176,7 +176,7 @@ public static void double4x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_less_wide_wide()
         {
             double4x3 a0 = double4x3(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259, 164.67880662003472, -350.94487516532877, 3.84143662631584, 125.40972024081725);
@@ -200,7 +200,7 @@ public static void double4x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_less_wide_scalar()
         {
             double4x3 a0 = double4x3(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061, -20.452607402788772, 225.29148517609178, 307.48418607725023, 274.01523292903562);
@@ -224,7 +224,7 @@ public static void double4x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -248,7 +248,7 @@ public static void double4x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_greater_wide_wide()
         {
             double4x3 a0 = double4x3(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484, -24.740548383789417, 319.78262701620474, -120.15856581561201, -289.00857962714906);
@@ -272,7 +272,7 @@ public static void double4x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_greater_wide_scalar()
         {
             double4x3 a0 = double4x3(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972, -405.78459210218148, 171.56538661362856, -241.80727326209063, 333.57817498481745);
@@ -296,7 +296,7 @@ public static void double4x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -320,7 +320,7 @@ public static void double4x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_less_equal_wide_wide()
         {
             double4x3 a0 = double4x3(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232, 458.53029153241323, -294.06474675520542, 23.622613679441884, -34.284056441059363);
@@ -344,7 +344,7 @@ public static void double4x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_less_equal_wide_scalar()
         {
             double4x3 a0 = double4x3(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582, -1.3577692515020203, -268.89945591096739, 398.9919504593089, -471.253072242836);
@@ -368,7 +368,7 @@ public static void double4x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -392,7 +392,7 @@ public static void double4x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_greater_equal_wide_wide()
         {
             double4x3 a0 = double4x3(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265, 456.96878573716094, -211.01015506079892, 182.41135391146474, -53.596053863687473);
@@ -416,7 +416,7 @@ public static void double4x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_greater_equal_wide_scalar()
         {
             double4x3 a0 = double4x3(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838, 393.27804846003562, -315.70155086913218, 441.0115565923096, -509.78156757251435);
@@ -440,7 +440,7 @@ public static void double4x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -464,7 +464,7 @@ public static void double4x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_add_wide_wide()
         {
             double4x3 a0 = double4x3(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656, 462.41368148402012, -46.178705952213477, 401.17006296718966, -454.12414643453627);
@@ -488,7 +488,7 @@ public static void double4x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_add_wide_scalar()
         {
             double4x3 a0 = double4x3(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454, -242.1187475855084, 82.50134495762245, 6.7993848355483806, -484.69981287638649);
@@ -512,7 +512,7 @@ public static void double4x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -536,7 +536,7 @@ public static void double4x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_sub_wide_wide()
         {
             double4x3 a0 = double4x3(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537, 317.70681944382693, 447.0604133303558, -489.07414482956477, -230.00838218909149);
@@ -560,7 +560,7 @@ public static void double4x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_sub_wide_scalar()
         {
             double4x3 a0 = double4x3(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965, 480.85798738936796, 16.338193185784917, -366.86545269883493, -35.523088233323335);
@@ -584,7 +584,7 @@ public static void double4x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -608,7 +608,7 @@ public static void double4x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_mul_wide_wide()
         {
             double4x3 a0 = double4x3(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149, 45.868758938214114, 363.32610266438041, -328.11893692990714, -471.02307413100408);
@@ -632,7 +632,7 @@ public static void double4x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_mul_wide_scalar()
         {
             double4x3 a0 = double4x3(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334, -338.29248658674419, 53.796284939067618, 243.75734459783757, 135.35469991311186);
@@ -656,7 +656,7 @@ public static void double4x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -680,7 +680,7 @@ public static void double4x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_div_wide_wide()
         {
             double4x3 a0 = double4x3(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537, -237.69456326109105, -432.54687496300176, 200.26549181727012, 361.44157068871039);
@@ -704,7 +704,7 @@ public static void double4x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_div_wide_scalar()
         {
             double4x3 a0 = double4x3(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539, 146.46688110496234, -499.84355687529012, 58.686315802245531, -453.20579859856787);
@@ -728,7 +728,7 @@ public static void double4x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -752,7 +752,7 @@ public static void double4x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_mod_wide_wide()
         {
             double4x3 a0 = double4x3(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664, 335.27101413126616, -503.60851668920765, 191.02251848532933, 289.74269379756538);
@@ -776,7 +776,7 @@ public static void double4x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_mod_wide_scalar()
         {
             double4x3 a0 = double4x3(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243, 335.16613046041039, 101.70649032560482, 319.47152033423606, -285.40231646476423);
@@ -800,7 +800,7 @@ public static void double4x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -824,7 +824,7 @@ public static void double4x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_plus()
         {
             double4x3 a0 = double4x3(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488, -386.059833944803, 4.9544198536101476, -418.64524932328857, 504.47483062393724);
@@ -844,7 +844,7 @@ public static void double4x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_neg()
         {
             double4x3 a0 = double4x3(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581, -299.09338893512887, -383.01406377508027, 407.70980305583669, 168.73550351370852);
@@ -864,7 +864,7 @@ public static void double4x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_prefix_inc()
         {
             double4x3 a0 = double4x3(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267, 362.21273939787068, 401.614830919362, 130.90919429199266, -450.23016402229212);
@@ -884,7 +884,7 @@ public static void double4x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_postfix_inc()
         {
             double4x3 a0 = double4x3(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271, 167.85212691493894, 147.94395048354932, -326.10758486674524, 41.033564825092185);
@@ -904,7 +904,7 @@ public static void double4x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_prefix_dec()
         {
             double4x3 a0 = double4x3(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558, 125.10963517292851, 469.8447313112415, 45.536655685648611, 376.04684680329956);
@@ -924,7 +924,7 @@ public static void double4x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x3_operator_postfix_dec()
         {
             double4x3 a0 = double4x3(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568, -27.889220489137415, -100.76183824462902, 156.14034969924967, 479.94519613680677);
diff --git a/src/Tests/Tests/Shared/TestDouble4x4.gen.cs b/src/Tests/Tests/Shared/TestDouble4x4.gen.cs
index 8c982bb3..3fcaff74 100644
--- a/src/Tests/Tests/Shared/TestDouble4x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestDouble4x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestDouble4x4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_zero()
         {
             TestUtils.AreEqual(0.0, double4x4.zero.c0.x);
@@ -36,7 +36,7 @@ public static void double4x4_zero()
             TestUtils.AreEqual(0.0, double4x4.zero.c3.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_identity()
         {
             TestUtils.AreEqual(1.0, double4x4.identity.c0.x);
@@ -57,7 +57,7 @@ public static void double4x4_identity()
             TestUtils.AreEqual(1.0, double4x4.identity.c3.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_equal_wide_wide()
         {
             double4x4 a0 = double4x4(492.15758275061728, -495.20632027797694, 227.45765195947968, -147.37405950733182, -222.68201909897942, 64.093720704360749, -23.890404473939157, -16.8197190839889, 163.23210890741655, -165.27101071424363, 470.87767980568003, -423.94255967808078, 109.63436918595539, 462.69031283943468, -335.38147727371262, 357.23446934168896);
@@ -81,7 +81,7 @@ public static void double4x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_equal_wide_scalar()
         {
             double4x4 a0 = double4x4(-303.2300766926399, 451.52631327674089, -253.65587413201848, -105.20363502632995, -500.6910920090466, -426.19248338518315, 159.87609656149334, -59.558379439431405, -57.477391031327386, -182.04973968400139, 406.51375861024189, 370.88599866017978, -172.03530629539642, 455.40001198993991, -11.338988547836891, 363.93823044557973);
@@ -105,7 +105,7 @@ public static void double4x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_equal_scalar_wide()
         {
             double a0 = (-253.39728534100453);
@@ -129,7 +129,7 @@ public static void double4x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_not_equal_wide_wide()
         {
             double4x4 a0 = double4x4(430.8425316432689, 104.69001798736394, 225.80243478799355, -310.57017841496048, -418.61945815506363, 304.12820281839379, -509.32682561749908, -160.53807719076895, -203.30197606016975, -505.76325368590807, 162.17220623892365, 1.1561973100324394, 65.662074358045174, 102.78780250567377, 172.93008120960098, 26.621009123800832);
@@ -153,7 +153,7 @@ public static void double4x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_not_equal_wide_scalar()
         {
             double4x4 a0 = double4x4(-16.914588697680529, 168.83411486858233, -462.71352145760949, 130.30776959765137, 214.50161443208424, -440.26328178879959, -197.12796053529155, -169.09985860115842, -386.61117595555783, -281.02101362916687, -270.26885593601912, -403.96372313236992, -269.80570877241234, 299.65422763473089, -71.750904831919286, -432.75573917513515);
@@ -177,7 +177,7 @@ public static void double4x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_not_equal_scalar_wide()
         {
             double a0 = (275.79582823244664);
@@ -201,7 +201,7 @@ public static void double4x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_less_wide_wide()
         {
             double4x4 a0 = double4x4(196.84256825076534, 336.40979997087732, 251.96372115424072, 257.65591466503963, 430.04588647840819, -62.419644146421774, 8.8392293494376872, -333.81671563434259, 164.67880662003472, -350.94487516532877, 3.84143662631584, 125.40972024081725, -111.12994127680076, 70.005523475820951, 448.19828173527412, -419.98711200244122);
@@ -225,7 +225,7 @@ public static void double4x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_less_wide_scalar()
         {
             double4x4 a0 = double4x4(-132.05731708000292, -192.46500477216438, -66.834607870706634, -379.01750081545561, -360.28242199508588, 20.927834282129879, -158.24074537970159, 437.34587522845061, -20.452607402788772, 225.29148517609178, 307.48418607725023, 274.01523292903562, 373.54965584983563, 398.52368301829495, 105.0301654827922, -58.010895994496934);
@@ -249,7 +249,7 @@ public static void double4x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_less_scalar_wide()
         {
             double a0 = (-423.117411095238);
@@ -273,7 +273,7 @@ public static void double4x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_greater_wide_wide()
         {
             double4x4 a0 = double4x4(483.50140141113729, 310.81563415695712, 106.9661896726891, 295.73526038589671, 116.95757179938141, -478.29977653841479, -14.897393471979228, -33.817441717636484, -24.740548383789417, 319.78262701620474, -120.15856581561201, -289.00857962714906, 455.85146662958505, 144.70691139283917, 63.931990891663304, -285.68304099034663);
@@ -297,7 +297,7 @@ public static void double4x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_greater_wide_scalar()
         {
             double4x4 a0 = double4x4(64.317918092160426, -397.70346445483318, 431.87690826499693, 85.702980796668157, 246.26305233978803, 197.49155602114809, 286.1994608781298, 280.81334818564972, -405.78459210218148, 171.56538661362856, -241.80727326209063, 333.57817498481745, 370.27919524269146, -413.70138116073861, -356.5923551789449, -353.03129522550444);
@@ -321,7 +321,7 @@ public static void double4x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_greater_scalar_wide()
         {
             double a0 = (-282.67049635698572);
@@ -345,7 +345,7 @@ public static void double4x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_less_equal_wide_wide()
         {
             double4x4 a0 = double4x4(-438.52313753521219, 210.48942837980087, 4.8773329280677444, -137.29793817237857, 156.09410174009111, -363.92412035722475, -97.948485181642923, 437.29539009430232, 458.53029153241323, -294.06474675520542, 23.622613679441884, -34.284056441059363, 149.736484835733, -418.8866781754823, -197.50252899783783, -88.2055118494693);
@@ -369,7 +369,7 @@ public static void double4x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_less_equal_wide_scalar()
         {
             double4x4 a0 = double4x4(193.4958237118534, 168.91555197952107, -313.9930695565385, 81.826965131716292, 18.503590830836288, -0.35819602029312136, 241.36115776810846, -463.81641242644582, -1.3577692515020203, -268.89945591096739, 398.9919504593089, -471.253072242836, -264.93778264938749, 82.258299150624453, 11.246050124636895, 424.7040156911612);
@@ -393,7 +393,7 @@ public static void double4x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_less_equal_scalar_wide()
         {
             double a0 = (393.60626644343427);
@@ -417,7 +417,7 @@ public static void double4x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_greater_equal_wide_wide()
         {
             double4x4 a0 = double4x4(-507.92858409692, 504.49748181947393, -385.43449205226938, -262.32340944107784, -37.550928848586466, -111.59527759980193, -463.70202157632542, 387.44885772627265, 456.96878573716094, -211.01015506079892, 182.41135391146474, -53.596053863687473, -309.57021608463032, -136.02249127999994, 280.73629082401112, -96.9958942388165);
@@ -441,7 +441,7 @@ public static void double4x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_greater_equal_wide_scalar()
         {
             double4x4 a0 = double4x4(465.15218732559686, -424.8860745024337, -209.22109685150025, 58.779852656079356, -302.26910533675414, 140.12558252183976, 16.353385694489475, -344.55997316192838, 393.27804846003562, -315.70155086913218, 441.0115565923096, -509.78156757251435, -36.994287269652943, 494.82028865014217, -164.97393830352183, -466.12009046325466);
@@ -465,7 +465,7 @@ public static void double4x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_greater_equal_scalar_wide()
         {
             double a0 = (374.82703393270594);
@@ -489,7 +489,7 @@ public static void double4x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_add_wide_wide()
         {
             double4x4 a0 = double4x4(506.12905263627374, -501.77980803967444, 420.08479638587903, -186.03206476291274, -9.3123953385801883, 328.51179686585056, 424.34407659263536, 87.791079800478656, 462.41368148402012, -46.178705952213477, 401.17006296718966, -454.12414643453627, 69.195687564646732, -177.95734485329939, 299.60415544156183, 340.7048587001417);
@@ -513,7 +513,7 @@ public static void double4x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_add_wide_scalar()
         {
             double4x4 a0 = double4x4(-194.51420387742769, 338.54838696985894, 246.97140252169754, 100.51093797595752, -45.724677822424439, -478.11131094308166, 30.916145577522116, 60.37435224483454, -242.1187475855084, 82.50134495762245, 6.7993848355483806, -484.69981287638649, -188.26501068298938, -213.52673087526426, -267.78430688929944, 189.25996669999324);
@@ -537,7 +537,7 @@ public static void double4x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_add_scalar_wide()
         {
             double a0 = (-340.35468284243473);
@@ -561,7 +561,7 @@ public static void double4x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_sub_wide_wide()
         {
             double4x4 a0 = double4x4(160.4922617229131, 11.223957305412682, 359.20010607279846, -498.22830485656311, -355.25362913462038, -94.534852787170053, -410.46404786150163, -401.38464398001537, 317.70681944382693, 447.0604133303558, -489.07414482956477, -230.00838218909149, 24.875419389864192, 366.61447136784648, -107.3741567634857, -219.0081404275299);
@@ -585,7 +585,7 @@ public static void double4x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_sub_wide_scalar()
         {
             double4x4 a0 = double4x4(207.38960108877609, 248.45773684627272, -384.82393211164697, -205.34476122881506, -374.81156152058929, 191.64204820973896, 18.856238135535364, -44.96160151667965, 480.85798738936796, 16.338193185784917, -366.86545269883493, -35.523088233323335, 349.39776460705218, 439.07729336203886, 490.2222661870635, 195.02405104181923);
@@ -609,7 +609,7 @@ public static void double4x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_sub_scalar_wide()
         {
             double a0 = (-86.008225719448262);
@@ -633,7 +633,7 @@ public static void double4x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_mul_wide_wide()
         {
             double4x4 a0 = double4x4(-482.71381710596097, -407.29348559272171, 137.70058995937029, 208.54113278563182, 194.296573967811, -484.24241684574747, 183.98730739578014, -241.33547770294149, 45.868758938214114, 363.32610266438041, -328.11893692990714, -471.02307413100408, -262.68257415605831, -379.26274674910246, -374.09058182970182, 481.44738720424812);
@@ -657,7 +657,7 @@ public static void double4x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_mul_wide_scalar()
         {
             double4x4 a0 = double4x4(-96.318821236639678, -277.14229239017811, -239.93690191951436, 509.53140544776409, 255.85810172551226, 215.73149667295229, -455.50827500573746, -389.24327367788334, -338.29248658674419, 53.796284939067618, 243.75734459783757, 135.35469991311186, -207.35010275959507, -383.93960946795517, -31.425238862366086, 42.676120539510634);
@@ -681,7 +681,7 @@ public static void double4x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_mul_scalar_wide()
         {
             double a0 = (37.432166355397612);
@@ -705,7 +705,7 @@ public static void double4x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_div_wide_wide()
         {
             double4x4 a0 = double4x4(-353.13144390337703, -102.79985456485292, 51.319128298814917, -191.87167868012176, 8.0418245829836223, -128.73764210973758, -136.05959779399427, -370.4710053738537, -237.69456326109105, -432.54687496300176, 200.26549181727012, 361.44157068871039, -416.22613234828509, -450.01919362042992, -273.49744594911925, -286.90817011841955);
@@ -729,7 +729,7 @@ public static void double4x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_div_wide_scalar()
         {
             double4x4 a0 = double4x4(171.34242184988341, 0.10338377957384637, 57.888263967767443, -256.13074529177078, 95.6696842162263, -290.38690461329509, -127.44869118903239, -79.7448890580539, 146.46688110496234, -499.84355687529012, 58.686315802245531, -453.20579859856787, -205.03382143985192, 481.73814247629514, 464.47907159499778, -293.46349753693841);
@@ -753,7 +753,7 @@ public static void double4x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_div_scalar_wide()
         {
             double a0 = (-264.44250095283729);
@@ -777,7 +777,7 @@ public static void double4x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_mod_wide_wide()
         {
             double4x4 a0 = double4x4(-388.81249422059045, 181.68118842955732, -167.07872470052854, 432.82015319951813, -258.43895995730486, -170.11079629236406, 283.318293464984, 122.71651297561664, 335.27101413126616, -503.60851668920765, 191.02251848532933, 289.74269379756538, -124.03371745163281, 259.27395761165485, -274.35845030208975, -140.03080398404541);
@@ -801,7 +801,7 @@ public static void double4x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_mod_wide_scalar()
         {
             double4x4 a0 = double4x4(-244.49962889612635, -211.81931958525411, -145.92677576184587, -304.91822090042672, 155.47946436492703, -133.90778428591221, 281.30965412841624, -226.53575311719243, 335.16613046041039, 101.70649032560482, 319.47152033423606, -285.40231646476423, -355.84685985923136, 259.37800061860025, -330.87193957477433, -284.34358109363518);
@@ -825,7 +825,7 @@ public static void double4x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_mod_scalar_wide()
         {
             double a0 = (-66.945025236785909);
@@ -849,7 +849,7 @@ public static void double4x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_plus()
         {
             double4x4 a0 = double4x4(-418.82956357432045, -405.79894823851015, -34.041791216489742, 236.99924456188421, -459.83910129025537, 210.8614223985287, 293.74197902052754, -373.015422279488, -386.059833944803, 4.9544198536101476, -418.64524932328857, 504.47483062393724, -170.74650843941907, 439.55937572920664, -478.74939916969714, 116.40075665172219);
@@ -869,7 +869,7 @@ public static void double4x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_neg()
         {
             double4x4 a0 = double4x4(148.46174890755753, -467.12267873581624, 132.04719954917539, 183.52262290917463, 473.7010145009034, -407.99109024926605, -54.958759571872065, -382.98981803608581, -299.09338893512887, -383.01406377508027, 407.70980305583669, 168.73550351370852, 466.44152829909763, 171.90249474900895, -280.55831564616335, -78.85761622286293);
@@ -889,7 +889,7 @@ public static void double4x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_prefix_inc()
         {
             double4x4 a0 = double4x4(-139.84208137348389, -56.743654039103376, -381.955324589254, 509.79634380237962, -222.89634452708827, 210.31986556310198, -392.73151058365193, -300.19410218866267, 362.21273939787068, 401.614830919362, 130.90919429199266, -450.23016402229212, 243.54693114177644, 46.19202735190845, -41.497298975241051, 299.18547000511808);
@@ -909,7 +909,7 @@ public static void double4x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_postfix_inc()
         {
             double4x4 a0 = double4x4(-396.6697396695007, 511.20749378167443, 249.11127030528678, -128.81731301584153, -259.49027669592306, 278.00817764830219, -81.393423356764686, 66.719732554033271, 167.85212691493894, 147.94395048354932, -326.10758486674524, 41.033564825092185, 128.5304239394751, 73.155582223625629, -60.132380275117384, -446.22976490772783);
@@ -929,7 +929,7 @@ public static void double4x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_prefix_dec()
         {
             double4x4 a0 = double4x4(123.12869626056806, 256.8437465433235, 156.33078844674435, 461.73742530389563, 325.86799755965728, 392.01561731473339, 187.87412580655609, -236.2252043393558, 125.10963517292851, 469.8447313112415, 45.536655685648611, 376.04684680329956, -363.07547991493504, -22.028951416736902, 248.79012667797042, 168.0950144120003);
@@ -949,7 +949,7 @@ public static void double4x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4x4_operator_postfix_dec()
         {
             double4x4 a0 = double4x4(379.68831723727669, 302.69287814884115, -176.07134040448409, -291.25267066212962, 470.56758401848731, -402.92594666170231, -63.655158787805192, 355.26110069605568, -27.889220489137415, -100.76183824462902, 156.14034969924967, 479.94519613680677, -200.30429491787419, -445.0269393609031, 407.42034907239508, 327.67032519340069);
diff --git a/src/Tests/Tests/Shared/TestFloat2.gen.cs b/src/Tests/Tests/Shared/TestFloat2.gen.cs
index acacdb83..885cbf2c 100644
--- a/src/Tests/Tests/Shared/TestFloat2.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat2.gen.cs
@@ -15,14 +15,14 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_zero()
         {
             TestUtils.AreEqual(0.0f, float2.zero.x);
             TestUtils.AreEqual(0.0f, float2.zero.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_constructor()
         {
             float2 a = new float2(1, 2);
@@ -30,7 +30,7 @@ public static void float2_constructor()
             TestUtils.AreEqual(2, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_scalar_constructor()
         {
             float2 a = new float2(17.0f);
@@ -38,7 +38,7 @@ public static void float2_scalar_constructor()
             TestUtils.AreEqual(17.0f, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_static_constructor()
         {
             float2 a = float2(1, 2);
@@ -46,7 +46,7 @@ public static void float2_static_constructor()
             TestUtils.AreEqual(2, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_static_scalar_constructor()
         {
             float2 a = float2(17.0f);
@@ -54,7 +54,7 @@ public static void float2_static_scalar_constructor()
             TestUtils.AreEqual(17.0f, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_equal_wide_wide()
         {
             float2 a0 = float2(492.1576f, -495.206329f);
@@ -78,7 +78,7 @@ public static void float2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_equal_wide_scalar()
         {
             float2 a0 = float2(-303.230072f, 451.5263f);
@@ -102,7 +102,7 @@ public static void float2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -126,7 +126,7 @@ public static void float2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_not_equal_wide_wide()
         {
             float2 a0 = float2(430.842529f, 104.69f);
@@ -150,7 +150,7 @@ public static void float2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_not_equal_wide_scalar()
         {
             float2 a0 = float2(-16.9145813f, 168.8341f);
@@ -174,7 +174,7 @@ public static void float2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -198,7 +198,7 @@ public static void float2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_less_wide_wide()
         {
             float2 a0 = float2(196.84259f, 336.4098f);
@@ -222,7 +222,7 @@ public static void float2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_less_wide_scalar()
         {
             float2 a0 = float2(-132.057312f, -192.465f);
@@ -246,7 +246,7 @@ public static void float2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -270,7 +270,7 @@ public static void float2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_greater_wide_wide()
         {
             float2 a0 = float2(483.5014f, 310.8156f);
@@ -294,7 +294,7 @@ public static void float2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_greater_wide_scalar()
         {
             float2 a0 = float2(64.31793f, -397.703461f);
@@ -318,7 +318,7 @@ public static void float2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -342,7 +342,7 @@ public static void float2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_less_equal_wide_wide()
         {
             float2 a0 = float2(-438.523132f, 210.489441f);
@@ -366,7 +366,7 @@ public static void float2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_less_equal_wide_scalar()
         {
             float2 a0 = float2(193.49585f, 168.915527f);
@@ -390,7 +390,7 @@ public static void float2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -414,7 +414,7 @@ public static void float2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_greater_equal_wide_wide()
         {
             float2 a0 = float2(-507.9286f, 504.4975f);
@@ -438,7 +438,7 @@ public static void float2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_greater_equal_wide_scalar()
         {
             float2 a0 = float2(465.152161f, -424.886078f);
@@ -462,7 +462,7 @@ public static void float2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -486,7 +486,7 @@ public static void float2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_add_wide_wide()
         {
             float2 a0 = float2(506.129028f, -501.779816f);
@@ -510,7 +510,7 @@ public static void float2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_add_wide_scalar()
         {
             float2 a0 = float2(-194.514191f, 338.5484f);
@@ -534,7 +534,7 @@ public static void float2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -558,7 +558,7 @@ public static void float2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_sub_wide_wide()
         {
             float2 a0 = float2(160.492249f, 11.223938f);
@@ -582,7 +582,7 @@ public static void float2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_sub_wide_scalar()
         {
             float2 a0 = float2(207.389587f, 248.457764f);
@@ -606,7 +606,7 @@ public static void float2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -630,7 +630,7 @@ public static void float2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_mul_wide_wide()
         {
             float2 a0 = float2(-482.7138f, -407.2935f);
@@ -654,7 +654,7 @@ public static void float2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_mul_wide_scalar()
         {
             float2 a0 = float2(-96.31882f, -277.142273f);
@@ -678,7 +678,7 @@ public static void float2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -702,7 +702,7 @@ public static void float2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_div_wide_wide()
         {
             float2 a0 = float2(-353.131439f, -102.799866f);
@@ -726,7 +726,7 @@ public static void float2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_div_wide_scalar()
         {
             float2 a0 = float2(171.3424f, 0.103393555f);
@@ -750,7 +750,7 @@ public static void float2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -774,7 +774,7 @@ public static void float2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_mod_wide_wide()
         {
             float2 a0 = float2(-388.8125f, 181.681213f);
@@ -798,7 +798,7 @@ public static void float2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_mod_wide_scalar()
         {
             float2 a0 = float2(-244.499634f, -211.8193f);
@@ -822,7 +822,7 @@ public static void float2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -846,7 +846,7 @@ public static void float2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_plus()
         {
             float2 a0 = float2(-418.829559f, -405.79895f);
@@ -866,7 +866,7 @@ public static void float2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_neg()
         {
             float2 a0 = float2(148.461731f, -467.122681f);
@@ -886,7 +886,7 @@ public static void float2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_prefix_inc()
         {
             float2 a0 = float2(-139.842072f, -56.7436523f);
@@ -906,7 +906,7 @@ public static void float2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_postfix_inc()
         {
             float2 a0 = float2(-396.669739f, 511.20752f);
@@ -926,7 +926,7 @@ public static void float2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_prefix_dec()
         {
             float2 a0 = float2(123.128723f, 256.84375f);
@@ -946,7 +946,7 @@ public static void float2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_operator_postfix_dec()
         {
             float2 a0 = float2(379.6883f, 302.692871f);
@@ -966,7 +966,7 @@ public static void float2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_shuffle_result_1()
         {
             float2 a = float2(0, 1);
@@ -978,7 +978,7 @@ public static void float2_shuffle_result_1()
             TestUtils.AreEqual((3), shuffle(a, b, ShuffleComponent.RightY));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_shuffle_result_2()
         {
             float2 a = float2(0, 1);
@@ -1002,7 +1002,7 @@ public static void float2_shuffle_result_2()
             TestUtils.AreEqual(float2(3, 3), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_shuffle_result_3()
         {
             float2 a = float2(0, 1);
@@ -1026,7 +1026,7 @@ public static void float2_shuffle_result_3()
             TestUtils.AreEqual(float3(3, 1, 1), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_shuffle_result_4()
         {
             float2 a = float2(0, 1);
diff --git a/src/Tests/Tests/Shared/TestFloat2x2.gen.cs b/src/Tests/Tests/Shared/TestFloat2x2.gen.cs
index c5594164..b56dd1c0 100644
--- a/src/Tests/Tests/Shared/TestFloat2x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat2x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat2x2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_zero()
         {
             TestUtils.AreEqual(0.0f, float2x2.zero.c0.x);
@@ -24,7 +24,7 @@ public static void float2x2_zero()
             TestUtils.AreEqual(0.0f, float2x2.zero.c1.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_identity()
         {
             TestUtils.AreEqual(1.0f, float2x2.identity.c0.x);
@@ -33,7 +33,7 @@ public static void float2x2_identity()
             TestUtils.AreEqual(1.0f, float2x2.identity.c1.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_equal_wide_wide()
         {
             float2x2 a0 = float2x2(492.1576f, -495.206329f, 227.457642f, -147.374054f);
@@ -57,7 +57,7 @@ public static void float2x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_equal_wide_scalar()
         {
             float2x2 a0 = float2x2(-303.230072f, 451.5263f, -253.655884f, -105.203644f);
@@ -81,7 +81,7 @@ public static void float2x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -105,7 +105,7 @@ public static void float2x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_not_equal_wide_wide()
         {
             float2x2 a0 = float2x2(430.842529f, 104.69f, 225.802429f, -310.5702f);
@@ -129,7 +129,7 @@ public static void float2x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_not_equal_wide_scalar()
         {
             float2x2 a0 = float2x2(-16.9145813f, 168.8341f, -462.713531f, 130.307739f);
@@ -153,7 +153,7 @@ public static void float2x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -177,7 +177,7 @@ public static void float2x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_less_wide_wide()
         {
             float2x2 a0 = float2x2(196.84259f, 336.4098f, 251.963745f, 257.655945f);
@@ -201,7 +201,7 @@ public static void float2x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_less_wide_scalar()
         {
             float2x2 a0 = float2x2(-132.057312f, -192.465f, -66.8345947f, -379.017517f);
@@ -225,7 +225,7 @@ public static void float2x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -249,7 +249,7 @@ public static void float2x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_greater_wide_wide()
         {
             float2x2 a0 = float2x2(483.5014f, 310.8156f, 106.966187f, 295.7353f);
@@ -273,7 +273,7 @@ public static void float2x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_greater_wide_scalar()
         {
             float2x2 a0 = float2x2(64.31793f, -397.703461f, 431.8769f, 85.703f);
@@ -297,7 +297,7 @@ public static void float2x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -321,7 +321,7 @@ public static void float2x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_less_equal_wide_wide()
         {
             float2x2 a0 = float2x2(-438.523132f, 210.489441f, 4.87731934f, -137.297943f);
@@ -345,7 +345,7 @@ public static void float2x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_less_equal_wide_scalar()
         {
             float2x2 a0 = float2x2(193.49585f, 168.915527f, -313.993073f, 81.8269653f);
@@ -369,7 +369,7 @@ public static void float2x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -393,7 +393,7 @@ public static void float2x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_greater_equal_wide_wide()
         {
             float2x2 a0 = float2x2(-507.9286f, 504.4975f, -385.4345f, -262.323425f);
@@ -417,7 +417,7 @@ public static void float2x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_greater_equal_wide_scalar()
         {
             float2x2 a0 = float2x2(465.152161f, -424.886078f, -209.2211f, 58.7798462f);
@@ -441,7 +441,7 @@ public static void float2x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -465,7 +465,7 @@ public static void float2x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_add_wide_wide()
         {
             float2x2 a0 = float2x2(506.129028f, -501.779816f, 420.084778f, -186.032074f);
@@ -489,7 +489,7 @@ public static void float2x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_add_wide_scalar()
         {
             float2x2 a0 = float2x2(-194.514191f, 338.5484f, 246.971375f, 100.510925f);
@@ -513,7 +513,7 @@ public static void float2x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -537,7 +537,7 @@ public static void float2x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_sub_wide_wide()
         {
             float2x2 a0 = float2x2(160.492249f, 11.223938f, 359.200134f, -498.2283f);
@@ -561,7 +561,7 @@ public static void float2x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_sub_wide_scalar()
         {
             float2x2 a0 = float2x2(207.389587f, 248.457764f, -384.8239f, -205.344757f);
@@ -585,7 +585,7 @@ public static void float2x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -609,7 +609,7 @@ public static void float2x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_mul_wide_wide()
         {
             float2x2 a0 = float2x2(-482.7138f, -407.2935f, 137.700562f, 208.541138f);
@@ -633,7 +633,7 @@ public static void float2x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_mul_wide_scalar()
         {
             float2x2 a0 = float2x2(-96.31882f, -277.142273f, -239.93689f, 509.531433f);
@@ -657,7 +657,7 @@ public static void float2x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -681,7 +681,7 @@ public static void float2x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_div_wide_wide()
         {
             float2x2 a0 = float2x2(-353.131439f, -102.799866f, 51.3191528f, -191.871674f);
@@ -705,7 +705,7 @@ public static void float2x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_div_wide_scalar()
         {
             float2x2 a0 = float2x2(171.3424f, 0.103393555f, 57.8882446f, -256.130737f);
@@ -729,7 +729,7 @@ public static void float2x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -753,7 +753,7 @@ public static void float2x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_mod_wide_wide()
         {
             float2x2 a0 = float2x2(-388.8125f, 181.681213f, -167.078735f, 432.820129f);
@@ -777,7 +777,7 @@ public static void float2x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_mod_wide_scalar()
         {
             float2x2 a0 = float2x2(-244.499634f, -211.8193f, -145.926788f, -304.9182f);
@@ -801,7 +801,7 @@ public static void float2x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -825,7 +825,7 @@ public static void float2x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_plus()
         {
             float2x2 a0 = float2x2(-418.829559f, -405.79895f, -34.04178f, 236.999268f);
@@ -845,7 +845,7 @@ public static void float2x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_neg()
         {
             float2x2 a0 = float2x2(148.461731f, -467.122681f, 132.04718f, 183.522644f);
@@ -865,7 +865,7 @@ public static void float2x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_prefix_inc()
         {
             float2x2 a0 = float2x2(-139.842072f, -56.7436523f, -381.955322f, 509.796326f);
@@ -885,7 +885,7 @@ public static void float2x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_postfix_inc()
         {
             float2x2 a0 = float2x2(-396.669739f, 511.20752f, 249.111267f, -128.817322f);
@@ -905,7 +905,7 @@ public static void float2x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_prefix_dec()
         {
             float2x2 a0 = float2x2(123.128723f, 256.84375f, 156.330811f, 461.737427f);
@@ -925,7 +925,7 @@ public static void float2x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_operator_postfix_dec()
         {
             float2x2 a0 = float2x2(379.6883f, 302.692871f, -176.07135f, -291.2527f);
diff --git a/src/Tests/Tests/Shared/TestFloat2x3.gen.cs b/src/Tests/Tests/Shared/TestFloat2x3.gen.cs
index e619dc0d..ee756468 100644
--- a/src/Tests/Tests/Shared/TestFloat2x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat2x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat2x3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_zero()
         {
             TestUtils.AreEqual(0.0f, float2x3.zero.c0.x);
@@ -26,7 +26,7 @@ public static void float2x3_zero()
             TestUtils.AreEqual(0.0f, float2x3.zero.c2.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_equal_wide_wide()
         {
             float2x3 a0 = float2x3(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f);
@@ -50,7 +50,7 @@ public static void float2x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_equal_wide_scalar()
         {
             float2x3 a0 = float2x3(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f);
@@ -74,7 +74,7 @@ public static void float2x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -98,7 +98,7 @@ public static void float2x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_not_equal_wide_wide()
         {
             float2x3 a0 = float2x3(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f);
@@ -122,7 +122,7 @@ public static void float2x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_not_equal_wide_scalar()
         {
             float2x3 a0 = float2x3(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f);
@@ -146,7 +146,7 @@ public static void float2x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -170,7 +170,7 @@ public static void float2x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_less_wide_wide()
         {
             float2x3 a0 = float2x3(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f);
@@ -194,7 +194,7 @@ public static void float2x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_less_wide_scalar()
         {
             float2x3 a0 = float2x3(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f);
@@ -218,7 +218,7 @@ public static void float2x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -242,7 +242,7 @@ public static void float2x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_greater_wide_wide()
         {
             float2x3 a0 = float2x3(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f);
@@ -266,7 +266,7 @@ public static void float2x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_greater_wide_scalar()
         {
             float2x3 a0 = float2x3(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f);
@@ -290,7 +290,7 @@ public static void float2x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -314,7 +314,7 @@ public static void float2x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_less_equal_wide_wide()
         {
             float2x3 a0 = float2x3(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f);
@@ -338,7 +338,7 @@ public static void float2x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_less_equal_wide_scalar()
         {
             float2x3 a0 = float2x3(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f);
@@ -362,7 +362,7 @@ public static void float2x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -386,7 +386,7 @@ public static void float2x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_greater_equal_wide_wide()
         {
             float2x3 a0 = float2x3(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f);
@@ -410,7 +410,7 @@ public static void float2x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_greater_equal_wide_scalar()
         {
             float2x3 a0 = float2x3(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f);
@@ -434,7 +434,7 @@ public static void float2x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -458,7 +458,7 @@ public static void float2x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_add_wide_wide()
         {
             float2x3 a0 = float2x3(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f);
@@ -482,7 +482,7 @@ public static void float2x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_add_wide_scalar()
         {
             float2x3 a0 = float2x3(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f);
@@ -506,7 +506,7 @@ public static void float2x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -530,7 +530,7 @@ public static void float2x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_sub_wide_wide()
         {
             float2x3 a0 = float2x3(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f);
@@ -554,7 +554,7 @@ public static void float2x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_sub_wide_scalar()
         {
             float2x3 a0 = float2x3(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f);
@@ -578,7 +578,7 @@ public static void float2x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -602,7 +602,7 @@ public static void float2x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_mul_wide_wide()
         {
             float2x3 a0 = float2x3(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f);
@@ -626,7 +626,7 @@ public static void float2x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_mul_wide_scalar()
         {
             float2x3 a0 = float2x3(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f);
@@ -650,7 +650,7 @@ public static void float2x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -674,7 +674,7 @@ public static void float2x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_div_wide_wide()
         {
             float2x3 a0 = float2x3(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f);
@@ -698,7 +698,7 @@ public static void float2x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_div_wide_scalar()
         {
             float2x3 a0 = float2x3(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f);
@@ -722,7 +722,7 @@ public static void float2x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -746,7 +746,7 @@ public static void float2x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_mod_wide_wide()
         {
             float2x3 a0 = float2x3(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f);
@@ -770,7 +770,7 @@ public static void float2x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_mod_wide_scalar()
         {
             float2x3 a0 = float2x3(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f);
@@ -794,7 +794,7 @@ public static void float2x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -818,7 +818,7 @@ public static void float2x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_plus()
         {
             float2x3 a0 = float2x3(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f);
@@ -838,7 +838,7 @@ public static void float2x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_neg()
         {
             float2x3 a0 = float2x3(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f);
@@ -858,7 +858,7 @@ public static void float2x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_prefix_inc()
         {
             float2x3 a0 = float2x3(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f);
@@ -878,7 +878,7 @@ public static void float2x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_postfix_inc()
         {
             float2x3 a0 = float2x3(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f);
@@ -898,7 +898,7 @@ public static void float2x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_prefix_dec()
         {
             float2x3 a0 = float2x3(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f);
@@ -918,7 +918,7 @@ public static void float2x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x3_operator_postfix_dec()
         {
             float2x3 a0 = float2x3(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f);
diff --git a/src/Tests/Tests/Shared/TestFloat2x4.gen.cs b/src/Tests/Tests/Shared/TestFloat2x4.gen.cs
index 19447921..769a761e 100644
--- a/src/Tests/Tests/Shared/TestFloat2x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat2x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat2x4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_zero()
         {
             TestUtils.AreEqual(0.0f, float2x4.zero.c0.x);
@@ -28,7 +28,7 @@ public static void float2x4_zero()
             TestUtils.AreEqual(0.0f, float2x4.zero.c3.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_equal_wide_wide()
         {
             float2x4 a0 = float2x4(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f);
@@ -52,7 +52,7 @@ public static void float2x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_equal_wide_scalar()
         {
             float2x4 a0 = float2x4(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f);
@@ -76,7 +76,7 @@ public static void float2x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -100,7 +100,7 @@ public static void float2x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_not_equal_wide_wide()
         {
             float2x4 a0 = float2x4(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f);
@@ -124,7 +124,7 @@ public static void float2x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_not_equal_wide_scalar()
         {
             float2x4 a0 = float2x4(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f);
@@ -148,7 +148,7 @@ public static void float2x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -172,7 +172,7 @@ public static void float2x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_less_wide_wide()
         {
             float2x4 a0 = float2x4(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f);
@@ -196,7 +196,7 @@ public static void float2x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_less_wide_scalar()
         {
             float2x4 a0 = float2x4(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f);
@@ -220,7 +220,7 @@ public static void float2x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -244,7 +244,7 @@ public static void float2x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_greater_wide_wide()
         {
             float2x4 a0 = float2x4(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f);
@@ -268,7 +268,7 @@ public static void float2x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_greater_wide_scalar()
         {
             float2x4 a0 = float2x4(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f);
@@ -292,7 +292,7 @@ public static void float2x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -316,7 +316,7 @@ public static void float2x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_less_equal_wide_wide()
         {
             float2x4 a0 = float2x4(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f);
@@ -340,7 +340,7 @@ public static void float2x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_less_equal_wide_scalar()
         {
             float2x4 a0 = float2x4(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f);
@@ -364,7 +364,7 @@ public static void float2x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -388,7 +388,7 @@ public static void float2x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_greater_equal_wide_wide()
         {
             float2x4 a0 = float2x4(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f);
@@ -412,7 +412,7 @@ public static void float2x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_greater_equal_wide_scalar()
         {
             float2x4 a0 = float2x4(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f);
@@ -436,7 +436,7 @@ public static void float2x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -460,7 +460,7 @@ public static void float2x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_add_wide_wide()
         {
             float2x4 a0 = float2x4(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f);
@@ -484,7 +484,7 @@ public static void float2x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_add_wide_scalar()
         {
             float2x4 a0 = float2x4(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f);
@@ -508,7 +508,7 @@ public static void float2x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -532,7 +532,7 @@ public static void float2x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_sub_wide_wide()
         {
             float2x4 a0 = float2x4(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f);
@@ -556,7 +556,7 @@ public static void float2x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_sub_wide_scalar()
         {
             float2x4 a0 = float2x4(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f);
@@ -580,7 +580,7 @@ public static void float2x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -604,7 +604,7 @@ public static void float2x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_mul_wide_wide()
         {
             float2x4 a0 = float2x4(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f);
@@ -628,7 +628,7 @@ public static void float2x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_mul_wide_scalar()
         {
             float2x4 a0 = float2x4(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f);
@@ -652,7 +652,7 @@ public static void float2x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -676,7 +676,7 @@ public static void float2x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_div_wide_wide()
         {
             float2x4 a0 = float2x4(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f);
@@ -700,7 +700,7 @@ public static void float2x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_div_wide_scalar()
         {
             float2x4 a0 = float2x4(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f);
@@ -724,7 +724,7 @@ public static void float2x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -748,7 +748,7 @@ public static void float2x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_mod_wide_wide()
         {
             float2x4 a0 = float2x4(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f);
@@ -772,7 +772,7 @@ public static void float2x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_mod_wide_scalar()
         {
             float2x4 a0 = float2x4(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f);
@@ -796,7 +796,7 @@ public static void float2x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -820,7 +820,7 @@ public static void float2x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_plus()
         {
             float2x4 a0 = float2x4(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f);
@@ -840,7 +840,7 @@ public static void float2x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_neg()
         {
             float2x4 a0 = float2x4(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f);
@@ -860,7 +860,7 @@ public static void float2x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_prefix_inc()
         {
             float2x4 a0 = float2x4(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f);
@@ -880,7 +880,7 @@ public static void float2x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_postfix_inc()
         {
             float2x4 a0 = float2x4(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f);
@@ -900,7 +900,7 @@ public static void float2x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_prefix_dec()
         {
             float2x4 a0 = float2x4(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f);
@@ -920,7 +920,7 @@ public static void float2x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x4_operator_postfix_dec()
         {
             float2x4 a0 = float2x4(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f);
diff --git a/src/Tests/Tests/Shared/TestFloat3.gen.cs b/src/Tests/Tests/Shared/TestFloat3.gen.cs
index 40a4db85..29bbf5a0 100644
--- a/src/Tests/Tests/Shared/TestFloat3.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_zero()
         {
             TestUtils.AreEqual(0.0f, float3.zero.x);
@@ -23,7 +23,7 @@ public static void float3_zero()
             TestUtils.AreEqual(0.0f, float3.zero.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_constructor()
         {
             float3 a = new float3(1, 2, 3);
@@ -32,7 +32,7 @@ public static void float3_constructor()
             TestUtils.AreEqual(3, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_scalar_constructor()
         {
             float3 a = new float3(17.0f);
@@ -41,7 +41,7 @@ public static void float3_scalar_constructor()
             TestUtils.AreEqual(17.0f, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_static_constructor()
         {
             float3 a = float3(1, 2, 3);
@@ -50,7 +50,7 @@ public static void float3_static_constructor()
             TestUtils.AreEqual(3, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_static_scalar_constructor()
         {
             float3 a = float3(17.0f);
@@ -59,7 +59,7 @@ public static void float3_static_scalar_constructor()
             TestUtils.AreEqual(17.0f, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_equal_wide_wide()
         {
             float3 a0 = float3(492.1576f, -495.206329f, 227.457642f);
@@ -83,7 +83,7 @@ public static void float3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_equal_wide_scalar()
         {
             float3 a0 = float3(-303.230072f, 451.5263f, -253.655884f);
@@ -107,7 +107,7 @@ public static void float3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -131,7 +131,7 @@ public static void float3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_not_equal_wide_wide()
         {
             float3 a0 = float3(430.842529f, 104.69f, 225.802429f);
@@ -155,7 +155,7 @@ public static void float3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_not_equal_wide_scalar()
         {
             float3 a0 = float3(-16.9145813f, 168.8341f, -462.713531f);
@@ -179,7 +179,7 @@ public static void float3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -203,7 +203,7 @@ public static void float3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_less_wide_wide()
         {
             float3 a0 = float3(196.84259f, 336.4098f, 251.963745f);
@@ -227,7 +227,7 @@ public static void float3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_less_wide_scalar()
         {
             float3 a0 = float3(-132.057312f, -192.465f, -66.8345947f);
@@ -251,7 +251,7 @@ public static void float3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -275,7 +275,7 @@ public static void float3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_greater_wide_wide()
         {
             float3 a0 = float3(483.5014f, 310.8156f, 106.966187f);
@@ -299,7 +299,7 @@ public static void float3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_greater_wide_scalar()
         {
             float3 a0 = float3(64.31793f, -397.703461f, 431.8769f);
@@ -323,7 +323,7 @@ public static void float3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -347,7 +347,7 @@ public static void float3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_less_equal_wide_wide()
         {
             float3 a0 = float3(-438.523132f, 210.489441f, 4.87731934f);
@@ -371,7 +371,7 @@ public static void float3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_less_equal_wide_scalar()
         {
             float3 a0 = float3(193.49585f, 168.915527f, -313.993073f);
@@ -395,7 +395,7 @@ public static void float3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -419,7 +419,7 @@ public static void float3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_greater_equal_wide_wide()
         {
             float3 a0 = float3(-507.9286f, 504.4975f, -385.4345f);
@@ -443,7 +443,7 @@ public static void float3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_greater_equal_wide_scalar()
         {
             float3 a0 = float3(465.152161f, -424.886078f, -209.2211f);
@@ -467,7 +467,7 @@ public static void float3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -491,7 +491,7 @@ public static void float3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_add_wide_wide()
         {
             float3 a0 = float3(506.129028f, -501.779816f, 420.084778f);
@@ -515,7 +515,7 @@ public static void float3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_add_wide_scalar()
         {
             float3 a0 = float3(-194.514191f, 338.5484f, 246.971375f);
@@ -539,7 +539,7 @@ public static void float3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -563,7 +563,7 @@ public static void float3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_sub_wide_wide()
         {
             float3 a0 = float3(160.492249f, 11.223938f, 359.200134f);
@@ -587,7 +587,7 @@ public static void float3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_sub_wide_scalar()
         {
             float3 a0 = float3(207.389587f, 248.457764f, -384.8239f);
@@ -611,7 +611,7 @@ public static void float3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -635,7 +635,7 @@ public static void float3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_mul_wide_wide()
         {
             float3 a0 = float3(-482.7138f, -407.2935f, 137.700562f);
@@ -659,7 +659,7 @@ public static void float3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_mul_wide_scalar()
         {
             float3 a0 = float3(-96.31882f, -277.142273f, -239.93689f);
@@ -683,7 +683,7 @@ public static void float3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -707,7 +707,7 @@ public static void float3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_div_wide_wide()
         {
             float3 a0 = float3(-353.131439f, -102.799866f, 51.3191528f);
@@ -731,7 +731,7 @@ public static void float3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_div_wide_scalar()
         {
             float3 a0 = float3(171.3424f, 0.103393555f, 57.8882446f);
@@ -755,7 +755,7 @@ public static void float3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -779,7 +779,7 @@ public static void float3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_mod_wide_wide()
         {
             float3 a0 = float3(-388.8125f, 181.681213f, -167.078735f);
@@ -803,7 +803,7 @@ public static void float3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_mod_wide_scalar()
         {
             float3 a0 = float3(-244.499634f, -211.8193f, -145.926788f);
@@ -827,7 +827,7 @@ public static void float3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -851,7 +851,7 @@ public static void float3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_plus()
         {
             float3 a0 = float3(-418.829559f, -405.79895f, -34.04178f);
@@ -871,7 +871,7 @@ public static void float3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_neg()
         {
             float3 a0 = float3(148.461731f, -467.122681f, 132.04718f);
@@ -891,7 +891,7 @@ public static void float3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_prefix_inc()
         {
             float3 a0 = float3(-139.842072f, -56.7436523f, -381.955322f);
@@ -911,7 +911,7 @@ public static void float3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_postfix_inc()
         {
             float3 a0 = float3(-396.669739f, 511.20752f, 249.111267f);
@@ -931,7 +931,7 @@ public static void float3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_prefix_dec()
         {
             float3 a0 = float3(123.128723f, 256.84375f, 156.330811f);
@@ -951,7 +951,7 @@ public static void float3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_operator_postfix_dec()
         {
             float3 a0 = float3(379.6883f, 302.692871f, -176.07135f);
@@ -971,7 +971,7 @@ public static void float3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_shuffle_result_1()
         {
             float3 a = float3(0, 1, 2);
@@ -985,7 +985,7 @@ public static void float3_shuffle_result_1()
             TestUtils.AreEqual((5), shuffle(a, b, ShuffleComponent.RightZ));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_shuffle_result_2()
         {
             float3 a = float3(0, 1, 2);
@@ -1009,7 +1009,7 @@ public static void float3_shuffle_result_2()
             TestUtils.AreEqual(float2(1, 2), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_shuffle_result_3()
         {
             float3 a = float3(0, 1, 2);
@@ -1033,7 +1033,7 @@ public static void float3_shuffle_result_3()
             TestUtils.AreEqual(float3(4, 0, 5), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_shuffle_result_4()
         {
             float3 a = float3(0, 1, 2);
diff --git a/src/Tests/Tests/Shared/TestFloat3x2.gen.cs b/src/Tests/Tests/Shared/TestFloat3x2.gen.cs
index dabe0e58..a9fcca5b 100644
--- a/src/Tests/Tests/Shared/TestFloat3x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat3x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat3x2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_zero()
         {
             TestUtils.AreEqual(0.0f, float3x2.zero.c0.x);
@@ -26,7 +26,7 @@ public static void float3x2_zero()
             TestUtils.AreEqual(0.0f, float3x2.zero.c1.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_equal_wide_wide()
         {
             float3x2 a0 = float3x2(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f);
@@ -50,7 +50,7 @@ public static void float3x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_equal_wide_scalar()
         {
             float3x2 a0 = float3x2(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f);
@@ -74,7 +74,7 @@ public static void float3x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -98,7 +98,7 @@ public static void float3x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_not_equal_wide_wide()
         {
             float3x2 a0 = float3x2(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f);
@@ -122,7 +122,7 @@ public static void float3x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_not_equal_wide_scalar()
         {
             float3x2 a0 = float3x2(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f);
@@ -146,7 +146,7 @@ public static void float3x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -170,7 +170,7 @@ public static void float3x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_less_wide_wide()
         {
             float3x2 a0 = float3x2(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f);
@@ -194,7 +194,7 @@ public static void float3x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_less_wide_scalar()
         {
             float3x2 a0 = float3x2(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f);
@@ -218,7 +218,7 @@ public static void float3x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -242,7 +242,7 @@ public static void float3x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_greater_wide_wide()
         {
             float3x2 a0 = float3x2(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f);
@@ -266,7 +266,7 @@ public static void float3x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_greater_wide_scalar()
         {
             float3x2 a0 = float3x2(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f);
@@ -290,7 +290,7 @@ public static void float3x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -314,7 +314,7 @@ public static void float3x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_less_equal_wide_wide()
         {
             float3x2 a0 = float3x2(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f);
@@ -338,7 +338,7 @@ public static void float3x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_less_equal_wide_scalar()
         {
             float3x2 a0 = float3x2(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f);
@@ -362,7 +362,7 @@ public static void float3x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -386,7 +386,7 @@ public static void float3x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_greater_equal_wide_wide()
         {
             float3x2 a0 = float3x2(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f);
@@ -410,7 +410,7 @@ public static void float3x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_greater_equal_wide_scalar()
         {
             float3x2 a0 = float3x2(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f);
@@ -434,7 +434,7 @@ public static void float3x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -458,7 +458,7 @@ public static void float3x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_add_wide_wide()
         {
             float3x2 a0 = float3x2(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f);
@@ -482,7 +482,7 @@ public static void float3x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_add_wide_scalar()
         {
             float3x2 a0 = float3x2(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f);
@@ -506,7 +506,7 @@ public static void float3x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -530,7 +530,7 @@ public static void float3x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_sub_wide_wide()
         {
             float3x2 a0 = float3x2(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f);
@@ -554,7 +554,7 @@ public static void float3x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_sub_wide_scalar()
         {
             float3x2 a0 = float3x2(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f);
@@ -578,7 +578,7 @@ public static void float3x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -602,7 +602,7 @@ public static void float3x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_mul_wide_wide()
         {
             float3x2 a0 = float3x2(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f);
@@ -626,7 +626,7 @@ public static void float3x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_mul_wide_scalar()
         {
             float3x2 a0 = float3x2(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f);
@@ -650,7 +650,7 @@ public static void float3x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -674,7 +674,7 @@ public static void float3x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_div_wide_wide()
         {
             float3x2 a0 = float3x2(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f);
@@ -698,7 +698,7 @@ public static void float3x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_div_wide_scalar()
         {
             float3x2 a0 = float3x2(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f);
@@ -722,7 +722,7 @@ public static void float3x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -746,7 +746,7 @@ public static void float3x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_mod_wide_wide()
         {
             float3x2 a0 = float3x2(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f);
@@ -770,7 +770,7 @@ public static void float3x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_mod_wide_scalar()
         {
             float3x2 a0 = float3x2(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f);
@@ -794,7 +794,7 @@ public static void float3x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -818,7 +818,7 @@ public static void float3x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_plus()
         {
             float3x2 a0 = float3x2(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f);
@@ -838,7 +838,7 @@ public static void float3x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_neg()
         {
             float3x2 a0 = float3x2(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f);
@@ -858,7 +858,7 @@ public static void float3x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_prefix_inc()
         {
             float3x2 a0 = float3x2(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f);
@@ -878,7 +878,7 @@ public static void float3x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_postfix_inc()
         {
             float3x2 a0 = float3x2(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f);
@@ -898,7 +898,7 @@ public static void float3x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_prefix_dec()
         {
             float3x2 a0 = float3x2(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f);
@@ -918,7 +918,7 @@ public static void float3x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x2_operator_postfix_dec()
         {
             float3x2 a0 = float3x2(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f);
diff --git a/src/Tests/Tests/Shared/TestFloat3x3.gen.cs b/src/Tests/Tests/Shared/TestFloat3x3.gen.cs
index 6326f34f..7561ab09 100644
--- a/src/Tests/Tests/Shared/TestFloat3x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat3x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat3x3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_zero()
         {
             TestUtils.AreEqual(0.0f, float3x3.zero.c0.x);
@@ -29,7 +29,7 @@ public static void float3x3_zero()
             TestUtils.AreEqual(0.0f, float3x3.zero.c2.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_identity()
         {
             TestUtils.AreEqual(1.0f, float3x3.identity.c0.x);
@@ -43,7 +43,7 @@ public static void float3x3_identity()
             TestUtils.AreEqual(1.0f, float3x3.identity.c2.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_equal_wide_wide()
         {
             float3x3 a0 = float3x3(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f, 163.232117f);
@@ -67,7 +67,7 @@ public static void float3x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_equal_wide_scalar()
         {
             float3x3 a0 = float3x3(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f, -57.4773865f);
@@ -91,7 +91,7 @@ public static void float3x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -115,7 +115,7 @@ public static void float3x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_not_equal_wide_wide()
         {
             float3x3 a0 = float3x3(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f, -203.301971f);
@@ -139,7 +139,7 @@ public static void float3x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_not_equal_wide_scalar()
         {
             float3x3 a0 = float3x3(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f, -386.611176f);
@@ -163,7 +163,7 @@ public static void float3x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -187,7 +187,7 @@ public static void float3x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_less_wide_wide()
         {
             float3x3 a0 = float3x3(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f, 164.678833f);
@@ -211,7 +211,7 @@ public static void float3x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_less_wide_scalar()
         {
             float3x3 a0 = float3x3(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f, -20.4526062f);
@@ -235,7 +235,7 @@ public static void float3x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -259,7 +259,7 @@ public static void float3x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_greater_wide_wide()
         {
             float3x3 a0 = float3x3(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f, -24.74054f);
@@ -283,7 +283,7 @@ public static void float3x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_greater_wide_scalar()
         {
             float3x3 a0 = float3x3(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f, -405.7846f);
@@ -307,7 +307,7 @@ public static void float3x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -331,7 +331,7 @@ public static void float3x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_less_equal_wide_wide()
         {
             float3x3 a0 = float3x3(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f, 458.530273f);
@@ -355,7 +355,7 @@ public static void float3x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_less_equal_wide_scalar()
         {
             float3x3 a0 = float3x3(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f, -1.35775757f);
@@ -379,7 +379,7 @@ public static void float3x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -403,7 +403,7 @@ public static void float3x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_greater_equal_wide_wide()
         {
             float3x3 a0 = float3x3(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f, 456.9688f);
@@ -427,7 +427,7 @@ public static void float3x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_greater_equal_wide_scalar()
         {
             float3x3 a0 = float3x3(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f, 393.278076f);
@@ -451,7 +451,7 @@ public static void float3x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -475,7 +475,7 @@ public static void float3x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_add_wide_wide()
         {
             float3x3 a0 = float3x3(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f, 462.4137f);
@@ -499,7 +499,7 @@ public static void float3x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_add_wide_scalar()
         {
             float3x3 a0 = float3x3(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f, -242.118744f);
@@ -523,7 +523,7 @@ public static void float3x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -547,7 +547,7 @@ public static void float3x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_sub_wide_wide()
         {
             float3x3 a0 = float3x3(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f, 317.706848f);
@@ -571,7 +571,7 @@ public static void float3x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_sub_wide_scalar()
         {
             float3x3 a0 = float3x3(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f, 480.857971f);
@@ -595,7 +595,7 @@ public static void float3x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -619,7 +619,7 @@ public static void float3x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_mul_wide_wide()
         {
             float3x3 a0 = float3x3(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f, 45.8687744f);
@@ -643,7 +643,7 @@ public static void float3x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_mul_wide_scalar()
         {
             float3x3 a0 = float3x3(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f, -338.29248f);
@@ -667,7 +667,7 @@ public static void float3x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -691,7 +691,7 @@ public static void float3x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_div_wide_wide()
         {
             float3x3 a0 = float3x3(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f, -237.69455f);
@@ -715,7 +715,7 @@ public static void float3x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_div_wide_scalar()
         {
             float3x3 a0 = float3x3(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f, 146.466858f);
@@ -739,7 +739,7 @@ public static void float3x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -763,7 +763,7 @@ public static void float3x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_mod_wide_wide()
         {
             float3x3 a0 = float3x3(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f, 335.271f);
@@ -787,7 +787,7 @@ public static void float3x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_mod_wide_scalar()
         {
             float3x3 a0 = float3x3(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f, 335.166138f);
@@ -811,7 +811,7 @@ public static void float3x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -835,7 +835,7 @@ public static void float3x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_plus()
         {
             float3x3 a0 = float3x3(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f, -386.059845f);
@@ -855,7 +855,7 @@ public static void float3x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_neg()
         {
             float3x3 a0 = float3x3(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f, -299.093384f);
@@ -875,7 +875,7 @@ public static void float3x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_prefix_inc()
         {
             float3x3 a0 = float3x3(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f, 362.212769f);
@@ -895,7 +895,7 @@ public static void float3x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_postfix_inc()
         {
             float3x3 a0 = float3x3(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f, 167.852112f);
@@ -915,7 +915,7 @@ public static void float3x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_prefix_dec()
         {
             float3x3 a0 = float3x3(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f, 125.109619f);
@@ -935,7 +935,7 @@ public static void float3x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_operator_postfix_dec()
         {
             float3x3 a0 = float3x3(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f, -27.8892212f);
diff --git a/src/Tests/Tests/Shared/TestFloat3x4.gen.cs b/src/Tests/Tests/Shared/TestFloat3x4.gen.cs
index 78522532..b688cda8 100644
--- a/src/Tests/Tests/Shared/TestFloat3x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat3x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat3x4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_zero()
         {
             TestUtils.AreEqual(0.0f, float3x4.zero.c0.x);
@@ -32,7 +32,7 @@ public static void float3x4_zero()
             TestUtils.AreEqual(0.0f, float3x4.zero.c3.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_equal_wide_wide()
         {
             float3x4 a0 = float3x4(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f, 163.232117f, -165.271f, 470.8777f, -423.942566f);
@@ -56,7 +56,7 @@ public static void float3x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_equal_wide_scalar()
         {
             float3x4 a0 = float3x4(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f, -57.4773865f, -182.049744f, 406.513733f, 370.886f);
@@ -80,7 +80,7 @@ public static void float3x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -104,7 +104,7 @@ public static void float3x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_not_equal_wide_wide()
         {
             float3x4 a0 = float3x4(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f, -203.301971f, -505.763245f, 162.17218f, 1.156189f);
@@ -128,7 +128,7 @@ public static void float3x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_not_equal_wide_scalar()
         {
             float3x4 a0 = float3x4(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f, -386.611176f, -281.021f, -270.26886f, -403.9637f);
@@ -152,7 +152,7 @@ public static void float3x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -176,7 +176,7 @@ public static void float3x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_less_wide_wide()
         {
             float3x4 a0 = float3x4(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f, 164.678833f, -350.9449f, 3.84143066f, 125.409729f);
@@ -200,7 +200,7 @@ public static void float3x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_less_wide_scalar()
         {
             float3x4 a0 = float3x4(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f, -20.4526062f, 225.2915f, 307.4842f, 274.015259f);
@@ -224,7 +224,7 @@ public static void float3x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -248,7 +248,7 @@ public static void float3x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_greater_wide_wide()
         {
             float3x4 a0 = float3x4(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f, -24.74054f, 319.782654f, -120.158569f, -289.008575f);
@@ -272,7 +272,7 @@ public static void float3x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_greater_wide_scalar()
         {
             float3x4 a0 = float3x4(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f, -405.7846f, 171.565369f, -241.807281f, 333.5782f);
@@ -296,7 +296,7 @@ public static void float3x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -320,7 +320,7 @@ public static void float3x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_less_equal_wide_wide()
         {
             float3x4 a0 = float3x4(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f, 458.530273f, -294.064758f, 23.62262f, -34.2840576f);
@@ -344,7 +344,7 @@ public static void float3x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_less_equal_wide_scalar()
         {
             float3x4 a0 = float3x4(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f, -1.35775757f, -268.899475f, 398.991943f, -471.253082f);
@@ -368,7 +368,7 @@ public static void float3x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -392,7 +392,7 @@ public static void float3x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_greater_equal_wide_wide()
         {
             float3x4 a0 = float3x4(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f, 456.9688f, -211.010162f, 182.411377f, -53.59604f);
@@ -416,7 +416,7 @@ public static void float3x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_greater_equal_wide_scalar()
         {
             float3x4 a0 = float3x4(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f, 393.278076f, -315.701538f, 441.011536f, -509.781555f);
@@ -440,7 +440,7 @@ public static void float3x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -464,7 +464,7 @@ public static void float3x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_add_wide_wide()
         {
             float3x4 a0 = float3x4(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f, 462.4137f, -46.17871f, 401.170044f, -454.124146f);
@@ -488,7 +488,7 @@ public static void float3x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_add_wide_scalar()
         {
             float3x4 a0 = float3x4(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f, -242.118744f, 82.50134f, 6.79937744f, -484.6998f);
@@ -512,7 +512,7 @@ public static void float3x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -536,7 +536,7 @@ public static void float3x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_sub_wide_wide()
         {
             float3x4 a0 = float3x4(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f, 317.706848f, 447.060425f, -489.074158f, -230.008392f);
@@ -560,7 +560,7 @@ public static void float3x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_sub_wide_scalar()
         {
             float3x4 a0 = float3x4(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f, 480.857971f, 16.3381958f, -366.865448f, -35.5231f);
@@ -584,7 +584,7 @@ public static void float3x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -608,7 +608,7 @@ public static void float3x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_mul_wide_wide()
         {
             float3x4 a0 = float3x4(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f, 45.8687744f, 363.3261f, -328.118958f, -471.023071f);
@@ -632,7 +632,7 @@ public static void float3x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_mul_wide_scalar()
         {
             float3x4 a0 = float3x4(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f, -338.29248f, 53.7962646f, 243.757324f, 135.354675f);
@@ -656,7 +656,7 @@ public static void float3x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -680,7 +680,7 @@ public static void float3x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_div_wide_wide()
         {
             float3x4 a0 = float3x4(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f, -237.69455f, -432.546875f, 200.2655f, 361.4416f);
@@ -704,7 +704,7 @@ public static void float3x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_div_wide_scalar()
         {
             float3x4 a0 = float3x4(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f, 146.466858f, -499.843567f, 58.68634f, -453.2058f);
@@ -728,7 +728,7 @@ public static void float3x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -752,7 +752,7 @@ public static void float3x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_mod_wide_wide()
         {
             float3x4 a0 = float3x4(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f, 335.271f, -503.608521f, 191.022522f, 289.742676f);
@@ -776,7 +776,7 @@ public static void float3x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_mod_wide_scalar()
         {
             float3x4 a0 = float3x4(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f, 335.166138f, 101.706482f, 319.4715f, -285.4023f);
@@ -800,7 +800,7 @@ public static void float3x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -824,7 +824,7 @@ public static void float3x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_plus()
         {
             float3x4 a0 = float3x4(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f, -386.059845f, 4.95440674f, -418.645264f, 504.474854f);
@@ -844,7 +844,7 @@ public static void float3x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_neg()
         {
             float3x4 a0 = float3x4(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f, -299.093384f, -383.014069f, 407.709778f, 168.735474f);
@@ -864,7 +864,7 @@ public static void float3x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_prefix_inc()
         {
             float3x4 a0 = float3x4(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f, 362.212769f, 401.6148f, 130.90918f, -450.230164f);
@@ -884,7 +884,7 @@ public static void float3x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_postfix_inc()
         {
             float3x4 a0 = float3x4(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f, 167.852112f, 147.94397f, -326.1076f, 41.03357f);
@@ -904,7 +904,7 @@ public static void float3x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_prefix_dec()
         {
             float3x4 a0 = float3x4(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f, 125.109619f, 469.844727f, 45.5366821f, 376.046875f);
@@ -924,7 +924,7 @@ public static void float3x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_operator_postfix_dec()
         {
             float3x4 a0 = float3x4(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f, -27.8892212f, -100.761841f, 156.14032f, 479.9452f);
diff --git a/src/Tests/Tests/Shared/TestFloat4.gen.cs b/src/Tests/Tests/Shared/TestFloat4.gen.cs
index 9ac6757c..1e0d3ab1 100644
--- a/src/Tests/Tests/Shared/TestFloat4.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_zero()
         {
             TestUtils.AreEqual(0.0f, float4.zero.x);
@@ -24,7 +24,7 @@ public static void float4_zero()
             TestUtils.AreEqual(0.0f, float4.zero.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_constructor()
         {
             float4 a = new float4(1, 2, 3, 4);
@@ -34,7 +34,7 @@ public static void float4_constructor()
             TestUtils.AreEqual(4, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_scalar_constructor()
         {
             float4 a = new float4(17.0f);
@@ -44,7 +44,7 @@ public static void float4_scalar_constructor()
             TestUtils.AreEqual(17.0f, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_static_constructor()
         {
             float4 a = float4(1, 2, 3, 4);
@@ -54,7 +54,7 @@ public static void float4_static_constructor()
             TestUtils.AreEqual(4, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_static_scalar_constructor()
         {
             float4 a = float4(17.0f);
@@ -64,7 +64,7 @@ public static void float4_static_scalar_constructor()
             TestUtils.AreEqual(17.0f, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_equal_wide_wide()
         {
             float4 a0 = float4(492.1576f, -495.206329f, 227.457642f, -147.374054f);
@@ -88,7 +88,7 @@ public static void float4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_equal_wide_scalar()
         {
             float4 a0 = float4(-303.230072f, 451.5263f, -253.655884f, -105.203644f);
@@ -112,7 +112,7 @@ public static void float4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -136,7 +136,7 @@ public static void float4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_not_equal_wide_wide()
         {
             float4 a0 = float4(430.842529f, 104.69f, 225.802429f, -310.5702f);
@@ -160,7 +160,7 @@ public static void float4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_not_equal_wide_scalar()
         {
             float4 a0 = float4(-16.9145813f, 168.8341f, -462.713531f, 130.307739f);
@@ -184,7 +184,7 @@ public static void float4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -208,7 +208,7 @@ public static void float4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_less_wide_wide()
         {
             float4 a0 = float4(196.84259f, 336.4098f, 251.963745f, 257.655945f);
@@ -232,7 +232,7 @@ public static void float4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_less_wide_scalar()
         {
             float4 a0 = float4(-132.057312f, -192.465f, -66.8345947f, -379.017517f);
@@ -256,7 +256,7 @@ public static void float4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -280,7 +280,7 @@ public static void float4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_greater_wide_wide()
         {
             float4 a0 = float4(483.5014f, 310.8156f, 106.966187f, 295.7353f);
@@ -304,7 +304,7 @@ public static void float4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_greater_wide_scalar()
         {
             float4 a0 = float4(64.31793f, -397.703461f, 431.8769f, 85.703f);
@@ -328,7 +328,7 @@ public static void float4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -352,7 +352,7 @@ public static void float4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_less_equal_wide_wide()
         {
             float4 a0 = float4(-438.523132f, 210.489441f, 4.87731934f, -137.297943f);
@@ -376,7 +376,7 @@ public static void float4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_less_equal_wide_scalar()
         {
             float4 a0 = float4(193.49585f, 168.915527f, -313.993073f, 81.8269653f);
@@ -400,7 +400,7 @@ public static void float4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -424,7 +424,7 @@ public static void float4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_greater_equal_wide_wide()
         {
             float4 a0 = float4(-507.9286f, 504.4975f, -385.4345f, -262.323425f);
@@ -448,7 +448,7 @@ public static void float4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_greater_equal_wide_scalar()
         {
             float4 a0 = float4(465.152161f, -424.886078f, -209.2211f, 58.7798462f);
@@ -472,7 +472,7 @@ public static void float4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -496,7 +496,7 @@ public static void float4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_add_wide_wide()
         {
             float4 a0 = float4(506.129028f, -501.779816f, 420.084778f, -186.032074f);
@@ -520,7 +520,7 @@ public static void float4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_add_wide_scalar()
         {
             float4 a0 = float4(-194.514191f, 338.5484f, 246.971375f, 100.510925f);
@@ -544,7 +544,7 @@ public static void float4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -568,7 +568,7 @@ public static void float4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_sub_wide_wide()
         {
             float4 a0 = float4(160.492249f, 11.223938f, 359.200134f, -498.2283f);
@@ -592,7 +592,7 @@ public static void float4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_sub_wide_scalar()
         {
             float4 a0 = float4(207.389587f, 248.457764f, -384.8239f, -205.344757f);
@@ -616,7 +616,7 @@ public static void float4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -640,7 +640,7 @@ public static void float4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_mul_wide_wide()
         {
             float4 a0 = float4(-482.7138f, -407.2935f, 137.700562f, 208.541138f);
@@ -664,7 +664,7 @@ public static void float4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_mul_wide_scalar()
         {
             float4 a0 = float4(-96.31882f, -277.142273f, -239.93689f, 509.531433f);
@@ -688,7 +688,7 @@ public static void float4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -712,7 +712,7 @@ public static void float4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_div_wide_wide()
         {
             float4 a0 = float4(-353.131439f, -102.799866f, 51.3191528f, -191.871674f);
@@ -736,7 +736,7 @@ public static void float4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_div_wide_scalar()
         {
             float4 a0 = float4(171.3424f, 0.103393555f, 57.8882446f, -256.130737f);
@@ -760,7 +760,7 @@ public static void float4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -784,7 +784,7 @@ public static void float4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_mod_wide_wide()
         {
             float4 a0 = float4(-388.8125f, 181.681213f, -167.078735f, 432.820129f);
@@ -808,7 +808,7 @@ public static void float4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_mod_wide_scalar()
         {
             float4 a0 = float4(-244.499634f, -211.8193f, -145.926788f, -304.9182f);
@@ -832,7 +832,7 @@ public static void float4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -856,7 +856,7 @@ public static void float4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_plus()
         {
             float4 a0 = float4(-418.829559f, -405.79895f, -34.04178f, 236.999268f);
@@ -876,7 +876,7 @@ public static void float4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_neg()
         {
             float4 a0 = float4(148.461731f, -467.122681f, 132.04718f, 183.522644f);
@@ -896,7 +896,7 @@ public static void float4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_prefix_inc()
         {
             float4 a0 = float4(-139.842072f, -56.7436523f, -381.955322f, 509.796326f);
@@ -916,7 +916,7 @@ public static void float4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_postfix_inc()
         {
             float4 a0 = float4(-396.669739f, 511.20752f, 249.111267f, -128.817322f);
@@ -936,7 +936,7 @@ public static void float4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_prefix_dec()
         {
             float4 a0 = float4(123.128723f, 256.84375f, 156.330811f, 461.737427f);
@@ -956,7 +956,7 @@ public static void float4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_operator_postfix_dec()
         {
             float4 a0 = float4(379.6883f, 302.692871f, -176.07135f, -291.2527f);
@@ -976,7 +976,7 @@ public static void float4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_shuffle_result_1()
         {
             float4 a = float4(0, 1, 2, 3);
@@ -992,7 +992,7 @@ public static void float4_shuffle_result_1()
             TestUtils.AreEqual((7), shuffle(a, b, ShuffleComponent.RightW));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_shuffle_result_2()
         {
             float4 a = float4(0, 1, 2, 3);
@@ -1016,7 +1016,7 @@ public static void float4_shuffle_result_2()
             TestUtils.AreEqual(float2(1, 3), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_shuffle_result_3()
         {
             float4 a = float4(0, 1, 2, 3);
@@ -1040,7 +1040,7 @@ public static void float4_shuffle_result_3()
             TestUtils.AreEqual(float3(5, 1, 7), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_shuffle_result_4()
         {
             float4 a = float4(0, 1, 2, 3);
diff --git a/src/Tests/Tests/Shared/TestFloat4x2.gen.cs b/src/Tests/Tests/Shared/TestFloat4x2.gen.cs
index 492a62f9..9b0cd505 100644
--- a/src/Tests/Tests/Shared/TestFloat4x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat4x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat4x2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_zero()
         {
             TestUtils.AreEqual(0.0f, float4x2.zero.c0.x);
@@ -28,7 +28,7 @@ public static void float4x2_zero()
             TestUtils.AreEqual(0.0f, float4x2.zero.c1.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_equal_wide_wide()
         {
             float4x2 a0 = float4x2(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f);
@@ -52,7 +52,7 @@ public static void float4x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_equal_wide_scalar()
         {
             float4x2 a0 = float4x2(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f);
@@ -76,7 +76,7 @@ public static void float4x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -100,7 +100,7 @@ public static void float4x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_not_equal_wide_wide()
         {
             float4x2 a0 = float4x2(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f);
@@ -124,7 +124,7 @@ public static void float4x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_not_equal_wide_scalar()
         {
             float4x2 a0 = float4x2(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f);
@@ -148,7 +148,7 @@ public static void float4x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -172,7 +172,7 @@ public static void float4x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_less_wide_wide()
         {
             float4x2 a0 = float4x2(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f);
@@ -196,7 +196,7 @@ public static void float4x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_less_wide_scalar()
         {
             float4x2 a0 = float4x2(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f);
@@ -220,7 +220,7 @@ public static void float4x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -244,7 +244,7 @@ public static void float4x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_greater_wide_wide()
         {
             float4x2 a0 = float4x2(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f);
@@ -268,7 +268,7 @@ public static void float4x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_greater_wide_scalar()
         {
             float4x2 a0 = float4x2(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f);
@@ -292,7 +292,7 @@ public static void float4x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -316,7 +316,7 @@ public static void float4x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_less_equal_wide_wide()
         {
             float4x2 a0 = float4x2(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f);
@@ -340,7 +340,7 @@ public static void float4x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_less_equal_wide_scalar()
         {
             float4x2 a0 = float4x2(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f);
@@ -364,7 +364,7 @@ public static void float4x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -388,7 +388,7 @@ public static void float4x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_greater_equal_wide_wide()
         {
             float4x2 a0 = float4x2(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f);
@@ -412,7 +412,7 @@ public static void float4x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_greater_equal_wide_scalar()
         {
             float4x2 a0 = float4x2(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f);
@@ -436,7 +436,7 @@ public static void float4x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -460,7 +460,7 @@ public static void float4x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_add_wide_wide()
         {
             float4x2 a0 = float4x2(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f);
@@ -484,7 +484,7 @@ public static void float4x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_add_wide_scalar()
         {
             float4x2 a0 = float4x2(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f);
@@ -508,7 +508,7 @@ public static void float4x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -532,7 +532,7 @@ public static void float4x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_sub_wide_wide()
         {
             float4x2 a0 = float4x2(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f);
@@ -556,7 +556,7 @@ public static void float4x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_sub_wide_scalar()
         {
             float4x2 a0 = float4x2(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f);
@@ -580,7 +580,7 @@ public static void float4x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -604,7 +604,7 @@ public static void float4x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_mul_wide_wide()
         {
             float4x2 a0 = float4x2(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f);
@@ -628,7 +628,7 @@ public static void float4x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_mul_wide_scalar()
         {
             float4x2 a0 = float4x2(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f);
@@ -652,7 +652,7 @@ public static void float4x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -676,7 +676,7 @@ public static void float4x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_div_wide_wide()
         {
             float4x2 a0 = float4x2(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f);
@@ -700,7 +700,7 @@ public static void float4x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_div_wide_scalar()
         {
             float4x2 a0 = float4x2(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f);
@@ -724,7 +724,7 @@ public static void float4x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -748,7 +748,7 @@ public static void float4x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_mod_wide_wide()
         {
             float4x2 a0 = float4x2(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f);
@@ -772,7 +772,7 @@ public static void float4x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_mod_wide_scalar()
         {
             float4x2 a0 = float4x2(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f);
@@ -796,7 +796,7 @@ public static void float4x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -820,7 +820,7 @@ public static void float4x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_plus()
         {
             float4x2 a0 = float4x2(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f);
@@ -840,7 +840,7 @@ public static void float4x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_neg()
         {
             float4x2 a0 = float4x2(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f);
@@ -860,7 +860,7 @@ public static void float4x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_prefix_inc()
         {
             float4x2 a0 = float4x2(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f);
@@ -880,7 +880,7 @@ public static void float4x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_postfix_inc()
         {
             float4x2 a0 = float4x2(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f);
@@ -900,7 +900,7 @@ public static void float4x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_prefix_dec()
         {
             float4x2 a0 = float4x2(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f);
@@ -920,7 +920,7 @@ public static void float4x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x2_operator_postfix_dec()
         {
             float4x2 a0 = float4x2(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f);
diff --git a/src/Tests/Tests/Shared/TestFloat4x3.gen.cs b/src/Tests/Tests/Shared/TestFloat4x3.gen.cs
index 06fb08a0..f2d4f21f 100644
--- a/src/Tests/Tests/Shared/TestFloat4x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat4x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat4x3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_zero()
         {
             TestUtils.AreEqual(0.0f, float4x3.zero.c0.x);
@@ -32,7 +32,7 @@ public static void float4x3_zero()
             TestUtils.AreEqual(0.0f, float4x3.zero.c2.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_equal_wide_wide()
         {
             float4x3 a0 = float4x3(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f, 163.232117f, -165.271f, 470.8777f, -423.942566f);
@@ -56,7 +56,7 @@ public static void float4x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_equal_wide_scalar()
         {
             float4x3 a0 = float4x3(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f, -57.4773865f, -182.049744f, 406.513733f, 370.886f);
@@ -80,7 +80,7 @@ public static void float4x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -104,7 +104,7 @@ public static void float4x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_not_equal_wide_wide()
         {
             float4x3 a0 = float4x3(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f, -203.301971f, -505.763245f, 162.17218f, 1.156189f);
@@ -128,7 +128,7 @@ public static void float4x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_not_equal_wide_scalar()
         {
             float4x3 a0 = float4x3(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f, -386.611176f, -281.021f, -270.26886f, -403.9637f);
@@ -152,7 +152,7 @@ public static void float4x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -176,7 +176,7 @@ public static void float4x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_less_wide_wide()
         {
             float4x3 a0 = float4x3(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f, 164.678833f, -350.9449f, 3.84143066f, 125.409729f);
@@ -200,7 +200,7 @@ public static void float4x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_less_wide_scalar()
         {
             float4x3 a0 = float4x3(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f, -20.4526062f, 225.2915f, 307.4842f, 274.015259f);
@@ -224,7 +224,7 @@ public static void float4x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -248,7 +248,7 @@ public static void float4x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_greater_wide_wide()
         {
             float4x3 a0 = float4x3(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f, -24.74054f, 319.782654f, -120.158569f, -289.008575f);
@@ -272,7 +272,7 @@ public static void float4x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_greater_wide_scalar()
         {
             float4x3 a0 = float4x3(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f, -405.7846f, 171.565369f, -241.807281f, 333.5782f);
@@ -296,7 +296,7 @@ public static void float4x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -320,7 +320,7 @@ public static void float4x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_less_equal_wide_wide()
         {
             float4x3 a0 = float4x3(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f, 458.530273f, -294.064758f, 23.62262f, -34.2840576f);
@@ -344,7 +344,7 @@ public static void float4x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_less_equal_wide_scalar()
         {
             float4x3 a0 = float4x3(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f, -1.35775757f, -268.899475f, 398.991943f, -471.253082f);
@@ -368,7 +368,7 @@ public static void float4x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -392,7 +392,7 @@ public static void float4x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_greater_equal_wide_wide()
         {
             float4x3 a0 = float4x3(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f, 456.9688f, -211.010162f, 182.411377f, -53.59604f);
@@ -416,7 +416,7 @@ public static void float4x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_greater_equal_wide_scalar()
         {
             float4x3 a0 = float4x3(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f, 393.278076f, -315.701538f, 441.011536f, -509.781555f);
@@ -440,7 +440,7 @@ public static void float4x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -464,7 +464,7 @@ public static void float4x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_add_wide_wide()
         {
             float4x3 a0 = float4x3(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f, 462.4137f, -46.17871f, 401.170044f, -454.124146f);
@@ -488,7 +488,7 @@ public static void float4x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_add_wide_scalar()
         {
             float4x3 a0 = float4x3(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f, -242.118744f, 82.50134f, 6.79937744f, -484.6998f);
@@ -512,7 +512,7 @@ public static void float4x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -536,7 +536,7 @@ public static void float4x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_sub_wide_wide()
         {
             float4x3 a0 = float4x3(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f, 317.706848f, 447.060425f, -489.074158f, -230.008392f);
@@ -560,7 +560,7 @@ public static void float4x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_sub_wide_scalar()
         {
             float4x3 a0 = float4x3(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f, 480.857971f, 16.3381958f, -366.865448f, -35.5231f);
@@ -584,7 +584,7 @@ public static void float4x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -608,7 +608,7 @@ public static void float4x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_mul_wide_wide()
         {
             float4x3 a0 = float4x3(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f, 45.8687744f, 363.3261f, -328.118958f, -471.023071f);
@@ -632,7 +632,7 @@ public static void float4x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_mul_wide_scalar()
         {
             float4x3 a0 = float4x3(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f, -338.29248f, 53.7962646f, 243.757324f, 135.354675f);
@@ -656,7 +656,7 @@ public static void float4x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -680,7 +680,7 @@ public static void float4x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_div_wide_wide()
         {
             float4x3 a0 = float4x3(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f, -237.69455f, -432.546875f, 200.2655f, 361.4416f);
@@ -704,7 +704,7 @@ public static void float4x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_div_wide_scalar()
         {
             float4x3 a0 = float4x3(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f, 146.466858f, -499.843567f, 58.68634f, -453.2058f);
@@ -728,7 +728,7 @@ public static void float4x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -752,7 +752,7 @@ public static void float4x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_mod_wide_wide()
         {
             float4x3 a0 = float4x3(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f, 335.271f, -503.608521f, 191.022522f, 289.742676f);
@@ -776,7 +776,7 @@ public static void float4x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_mod_wide_scalar()
         {
             float4x3 a0 = float4x3(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f, 335.166138f, 101.706482f, 319.4715f, -285.4023f);
@@ -800,7 +800,7 @@ public static void float4x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -824,7 +824,7 @@ public static void float4x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_plus()
         {
             float4x3 a0 = float4x3(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f, -386.059845f, 4.95440674f, -418.645264f, 504.474854f);
@@ -844,7 +844,7 @@ public static void float4x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_neg()
         {
             float4x3 a0 = float4x3(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f, -299.093384f, -383.014069f, 407.709778f, 168.735474f);
@@ -864,7 +864,7 @@ public static void float4x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_prefix_inc()
         {
             float4x3 a0 = float4x3(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f, 362.212769f, 401.6148f, 130.90918f, -450.230164f);
@@ -884,7 +884,7 @@ public static void float4x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_postfix_inc()
         {
             float4x3 a0 = float4x3(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f, 167.852112f, 147.94397f, -326.1076f, 41.03357f);
@@ -904,7 +904,7 @@ public static void float4x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_prefix_dec()
         {
             float4x3 a0 = float4x3(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f, 125.109619f, 469.844727f, 45.5366821f, 376.046875f);
@@ -924,7 +924,7 @@ public static void float4x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x3_operator_postfix_dec()
         {
             float4x3 a0 = float4x3(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f, -27.8892212f, -100.761841f, 156.14032f, 479.9452f);
diff --git a/src/Tests/Tests/Shared/TestFloat4x4.gen.cs b/src/Tests/Tests/Shared/TestFloat4x4.gen.cs
index d7c82665..1e706448 100644
--- a/src/Tests/Tests/Shared/TestFloat4x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestFloat4x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestFloat4x4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_zero()
         {
             TestUtils.AreEqual(0.0f, float4x4.zero.c0.x);
@@ -36,7 +36,7 @@ public static void float4x4_zero()
             TestUtils.AreEqual(0.0f, float4x4.zero.c3.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_identity()
         {
             TestUtils.AreEqual(1.0f, float4x4.identity.c0.x);
@@ -57,7 +57,7 @@ public static void float4x4_identity()
             TestUtils.AreEqual(1.0f, float4x4.identity.c3.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_equal_wide_wide()
         {
             float4x4 a0 = float4x4(492.1576f, -495.206329f, 227.457642f, -147.374054f, -222.682f, 64.09375f, -23.8904114f, -16.8197327f, 163.232117f, -165.271f, 470.8777f, -423.942566f, 109.6344f, 462.6903f, -335.38147f, 357.2345f);
@@ -81,7 +81,7 @@ public static void float4x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_equal_wide_scalar()
         {
             float4x4 a0 = float4x4(-303.230072f, 451.5263f, -253.655884f, -105.203644f, -500.6911f, -426.192474f, 159.8761f, -59.55838f, -57.4773865f, -182.049744f, 406.513733f, 370.886f, -172.035309f, 455.400024f, -11.3389893f, 363.938232f);
@@ -105,7 +105,7 @@ public static void float4x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_equal_scalar_wide()
         {
             float a0 = (-253.397278f);
@@ -129,7 +129,7 @@ public static void float4x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_not_equal_wide_wide()
         {
             float4x4 a0 = float4x4(430.842529f, 104.69f, 225.802429f, -310.5702f, -418.619446f, 304.128174f, -509.3268f, -160.538086f, -203.301971f, -505.763245f, 162.17218f, 1.156189f, 65.66205f, 102.787781f, 172.930054f, 26.6210327f);
@@ -153,7 +153,7 @@ public static void float4x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_not_equal_wide_scalar()
         {
             float4x4 a0 = float4x4(-16.9145813f, 168.8341f, -462.713531f, 130.307739f, 214.501587f, -440.263275f, -197.12796f, -169.099854f, -386.611176f, -281.021f, -270.26886f, -403.9637f, -269.805725f, 299.654236f, -71.7509155f, -432.755737f);
@@ -177,7 +177,7 @@ public static void float4x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_not_equal_scalar_wide()
         {
             float a0 = (275.795837f);
@@ -201,7 +201,7 @@ public static void float4x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_less_wide_wide()
         {
             float4x4 a0 = float4x4(196.84259f, 336.4098f, 251.963745f, 257.655945f, 430.0459f, -62.4196472f, 8.839233f, -333.8167f, 164.678833f, -350.9449f, 3.84143066f, 125.409729f, -111.129944f, 70.00549f, 448.1983f, -419.987122f);
@@ -225,7 +225,7 @@ public static void float4x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_less_wide_scalar()
         {
             float4x4 a0 = float4x4(-132.057312f, -192.465f, -66.8345947f, -379.017517f, -360.2824f, 20.9278564f, -158.240753f, 437.3459f, -20.4526062f, 225.2915f, 307.4842f, 274.015259f, 373.549683f, 398.523682f, 105.030151f, -58.0108948f);
@@ -249,7 +249,7 @@ public static void float4x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_less_scalar_wide()
         {
             float a0 = (-423.1174f);
@@ -273,7 +273,7 @@ public static void float4x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_greater_wide_wide()
         {
             float4x4 a0 = float4x4(483.5014f, 310.8156f, 106.966187f, 295.7353f, 116.957581f, -478.299774f, -14.8974f, -33.8174438f, -24.74054f, 319.782654f, -120.158569f, -289.008575f, 455.85144f, 144.706909f, 63.9320068f, -285.683044f);
@@ -297,7 +297,7 @@ public static void float4x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_greater_wide_scalar()
         {
             float4x4 a0 = float4x4(64.31793f, -397.703461f, 431.8769f, 85.703f, 246.263062f, 197.491577f, 286.199463f, 280.813354f, -405.7846f, 171.565369f, -241.807281f, 333.5782f, 370.279175f, -413.7014f, -356.592346f, -353.0313f);
@@ -321,7 +321,7 @@ public static void float4x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_greater_scalar_wide()
         {
             float a0 = (-282.6705f);
@@ -345,7 +345,7 @@ public static void float4x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_less_equal_wide_wide()
         {
             float4x4 a0 = float4x4(-438.523132f, 210.489441f, 4.87731934f, -137.297943f, 156.094116f, -363.924133f, -97.94849f, 437.2954f, 458.530273f, -294.064758f, 23.62262f, -34.2840576f, 149.736511f, -418.8867f, -197.502533f, -88.2055054f);
@@ -369,7 +369,7 @@ public static void float4x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_less_equal_wide_scalar()
         {
             float4x4 a0 = float4x4(193.49585f, 168.915527f, -313.993073f, 81.8269653f, 18.5036011f, -0.3581848f, 241.361145f, -463.8164f, -1.35775757f, -268.899475f, 398.991943f, -471.253082f, -264.9378f, 82.2583f, 11.2460327f, 424.704041f);
@@ -393,7 +393,7 @@ public static void float4x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_less_equal_scalar_wide()
         {
             float a0 = (393.606262f);
@@ -417,7 +417,7 @@ public static void float4x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_greater_equal_wide_wide()
         {
             float4x4 a0 = float4x4(-507.9286f, 504.4975f, -385.4345f, -262.323425f, -37.5509338f, -111.595276f, -463.702026f, 387.448853f, 456.9688f, -211.010162f, 182.411377f, -53.59604f, -309.570221f, -136.022491f, 280.736267f, -96.99588f);
@@ -441,7 +441,7 @@ public static void float4x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_greater_equal_wide_scalar()
         {
             float4x4 a0 = float4x4(465.152161f, -424.886078f, -209.2211f, 58.7798462f, -302.2691f, 140.12561f, 16.3533936f, -344.559967f, 393.278076f, -315.701538f, 441.011536f, -509.781555f, -36.9942932f, 494.8203f, -164.973938f, -466.1201f);
@@ -465,7 +465,7 @@ public static void float4x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_greater_equal_scalar_wide()
         {
             float a0 = (374.827026f);
@@ -489,7 +489,7 @@ public static void float4x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_add_wide_wide()
         {
             float4x4 a0 = float4x4(506.129028f, -501.779816f, 420.084778f, -186.032074f, -9.312408f, 328.51178f, 424.344055f, 87.79108f, 462.4137f, -46.17871f, 401.170044f, -454.124146f, 69.19568f, -177.957336f, 299.604126f, 340.704834f);
@@ -513,7 +513,7 @@ public static void float4x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_add_wide_scalar()
         {
             float4x4 a0 = float4x4(-194.514191f, 338.5484f, 246.971375f, 100.510925f, -45.72467f, -478.1113f, 30.9161377f, 60.37433f, -242.118744f, 82.50134f, 6.79937744f, -484.6998f, -188.265015f, -213.526733f, -267.7843f, 189.259949f);
@@ -537,7 +537,7 @@ public static void float4x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_add_scalar_wide()
         {
             float a0 = (-340.354675f);
@@ -561,7 +561,7 @@ public static void float4x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_sub_wide_wide()
         {
             float4x4 a0 = float4x4(160.492249f, 11.223938f, 359.200134f, -498.2283f, -355.253632f, -94.53485f, -410.46405f, -401.384644f, 317.706848f, 447.060425f, -489.074158f, -230.008392f, 24.8754272f, 366.614441f, -107.374146f, -219.008148f);
@@ -585,7 +585,7 @@ public static void float4x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_sub_wide_scalar()
         {
             float4x4 a0 = float4x4(207.389587f, 248.457764f, -384.8239f, -205.344757f, -374.811554f, 191.642029f, 18.8562622f, -44.96161f, 480.857971f, 16.3381958f, -366.865448f, -35.5231f, 349.397766f, 439.077271f, 490.2223f, 195.024048f);
@@ -609,7 +609,7 @@ public static void float4x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_sub_scalar_wide()
         {
             float a0 = (-86.00824f);
@@ -633,7 +633,7 @@ public static void float4x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_mul_wide_wide()
         {
             float4x4 a0 = float4x4(-482.7138f, -407.2935f, 137.700562f, 208.541138f, 194.29657f, -484.242432f, 183.9873f, -241.33548f, 45.8687744f, 363.3261f, -328.118958f, -471.023071f, -262.682556f, -379.262756f, -374.090576f, 481.4474f);
@@ -657,7 +657,7 @@ public static void float4x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_mul_wide_scalar()
         {
             float4x4 a0 = float4x4(-96.31882f, -277.142273f, -239.93689f, 509.531433f, 255.8581f, 215.7315f, -455.50827f, -389.2433f, -338.29248f, 53.7962646f, 243.757324f, 135.354675f, -207.3501f, -383.9396f, -31.4252319f, 42.6761475f);
@@ -681,7 +681,7 @@ public static void float4x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_mul_scalar_wide()
         {
             float a0 = (37.43219f);
@@ -705,7 +705,7 @@ public static void float4x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_div_wide_wide()
         {
             float4x4 a0 = float4x4(-353.131439f, -102.799866f, 51.3191528f, -191.871674f, 8.041809f, -128.73764f, -136.0596f, -370.471f, -237.69455f, -432.546875f, 200.2655f, 361.4416f, -416.226135f, -450.0192f, -273.497437f, -286.908173f);
@@ -729,7 +729,7 @@ public static void float4x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_div_wide_scalar()
         {
             float4x4 a0 = float4x4(171.3424f, 0.103393555f, 57.8882446f, -256.130737f, 95.66968f, -290.3869f, -127.4487f, -79.7449f, 146.466858f, -499.843567f, 58.68634f, -453.2058f, -205.033813f, 481.738159f, 464.479065f, -293.4635f);
@@ -753,7 +753,7 @@ public static void float4x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_div_scalar_wide()
         {
             float a0 = (-264.4425f);
@@ -777,7 +777,7 @@ public static void float4x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_mod_wide_wide()
         {
             float4x4 a0 = float4x4(-388.8125f, 181.681213f, -167.078735f, 432.820129f, -258.438965f, -170.110809f, 283.3183f, 122.716492f, 335.271f, -503.608521f, 191.022522f, 289.742676f, -124.033722f, 259.274f, -274.358459f, -140.030792f);
@@ -801,7 +801,7 @@ public static void float4x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_mod_wide_scalar()
         {
             float4x4 a0 = float4x4(-244.499634f, -211.8193f, -145.926788f, -304.9182f, 155.479492f, -133.907776f, 281.309631f, -226.535767f, 335.166138f, 101.706482f, 319.4715f, -285.4023f, -355.846863f, 259.378f, -330.871948f, -284.343567f);
@@ -825,7 +825,7 @@ public static void float4x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_mod_scalar_wide()
         {
             float a0 = (-66.94504f);
@@ -849,7 +849,7 @@ public static void float4x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_plus()
         {
             float4x4 a0 = float4x4(-418.829559f, -405.79895f, -34.04178f, 236.999268f, -459.8391f, 210.86145f, 293.742f, -373.015442f, -386.059845f, 4.95440674f, -418.645264f, 504.474854f, -170.746521f, 439.5594f, -478.7494f, 116.400757f);
@@ -869,7 +869,7 @@ public static void float4x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_neg()
         {
             float4x4 a0 = float4x4(148.461731f, -467.122681f, 132.04718f, 183.522644f, 473.701f, -407.9911f, -54.95877f, -382.9898f, -299.093384f, -383.014069f, 407.709778f, 168.735474f, 466.441528f, 171.902466f, -280.558319f, -78.857605f);
@@ -889,7 +889,7 @@ public static void float4x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_prefix_inc()
         {
             float4x4 a0 = float4x4(-139.842072f, -56.7436523f, -381.955322f, 509.796326f, -222.896332f, 210.319885f, -392.7315f, -300.1941f, 362.212769f, 401.6148f, 130.90918f, -450.230164f, 243.546936f, 46.1920166f, -41.4972839f, 299.1855f);
@@ -909,7 +909,7 @@ public static void float4x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_postfix_inc()
         {
             float4x4 a0 = float4x4(-396.669739f, 511.20752f, 249.111267f, -128.817322f, -259.4903f, 278.008179f, -81.39343f, 66.71973f, 167.852112f, 147.94397f, -326.1076f, 41.03357f, 128.5304f, 73.15558f, -60.1323853f, -446.229767f);
@@ -929,7 +929,7 @@ public static void float4x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_prefix_dec()
         {
             float4x4 a0 = float4x4(123.128723f, 256.84375f, 156.330811f, 461.737427f, 325.867981f, 392.015625f, 187.874146f, -236.225189f, 125.109619f, 469.844727f, 45.5366821f, 376.046875f, -363.0755f, -22.0289612f, 248.7901f, 168.095032f);
@@ -949,7 +949,7 @@ public static void float4x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_operator_postfix_dec()
         {
             float4x4 a0 = float4x4(379.6883f, 302.692871f, -176.07135f, -291.2527f, 470.567566f, -402.925964f, -63.65515f, 355.2611f, -27.8892212f, -100.761841f, 156.14032f, 479.9452f, -200.304291f, -445.026947f, 407.420349f, 327.670349f);
diff --git a/src/Tests/Tests/Shared/TestHalf.cs b/src/Tests/Tests/Shared/TestHalf.cs
index 301e06d2..7cd3e330 100644
--- a/src/Tests/Tests/Shared/TestHalf.cs
+++ b/src/Tests/Tests/Shared/TestHalf.cs
@@ -8,20 +8,20 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public partial class TestHalf
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half_zero()
         {
             TestUtils.AreEqual(0x0000, half.zero.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half2_zero()
         {
             TestUtils.AreEqual(0x0000, half2.zero.x.value);
             TestUtils.AreEqual(0x0000, half2.zero.y.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half3_zero()
         {
             TestUtils.AreEqual(0x0000, half3.zero.x.value);
@@ -29,7 +29,7 @@ public static void half3_zero()
             TestUtils.AreEqual(0x0000, half3.zero.z.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half4_zero()
         {
             TestUtils.AreEqual(0x0000, half4.zero.x.value);
@@ -38,7 +38,7 @@ public static void half4_zero()
             TestUtils.AreEqual(0x0000, half4.zero.w.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half_from_float_construction()
         {
             TestUtils.AreEqual(0x0000, half(0.0f).value);
@@ -58,14 +58,14 @@ public static void half_from_float_construction()
             TestUtils.AreEqual(0xFC00, half(float.NegativeInfinity).value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void half_from_float_construction_signed_zero()
         {
             TestUtils.AreEqual(0x8000, half(TestUtils.SignedFloatZero()).value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half2_from_float2_construction()
         {
             half2 h0 = half2(float2(0.0f, 2.98e-08f));
@@ -89,7 +89,7 @@ public static void half2_from_float2_construction()
             TestUtils.AreEqual(uint2(0xFC00, 0x0000), uint2(h7.x.value, h7.y.value));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void half2_from_float2_construction_signed_zero()
         {
@@ -97,7 +97,7 @@ public static void half2_from_float2_construction_signed_zero()
             TestUtils.AreEqual(uint2(0x8000, 0x8000), uint2(h0.x.value, h0.y.value));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half3_from_float3_construction()
         {
             half3 h0 = half3(float3(0.0f, 2.98e-08f, 5.96046448e-08f));
@@ -114,7 +114,7 @@ public static void half3_from_float3_construction()
             TestUtils.AreEqual(uint3(0xFC00, 0xFC00, 0x0000), uint3(h4.x.value, h4.y.value, h4.z.value));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void half3_from_float3_construction_signed_zero()
         {
@@ -122,7 +122,7 @@ public static void half3_from_float3_construction_signed_zero()
             TestUtils.AreEqual(uint3(0x8000, 0x8000, 0x8000), uint3(h0.x.value, h0.y.value, h0.z.value));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half4_from_float4_construction()
         {
             half4 h0 = half4(float4(0.0f, 2.98e-08f, 5.96046448e-08f, 123.4f));
@@ -136,7 +136,7 @@ public static void half4_from_float4_construction()
             TestUtils.AreEqual(uint4(0xFC00, 0xFC00, 0xFC00, 0x0000), uint4(h3.x.value, h3.y.value, h3.z.value, h3.w.value));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void half4_from_float4_construction_signed_zero()
         {
@@ -145,7 +145,7 @@ public static void half4_from_float4_construction_signed_zero()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half_from_double_construction()
         {
             TestUtils.AreEqual(0x0000, half(0.0).value);
@@ -165,14 +165,14 @@ public static void half_from_double_construction()
             TestUtils.AreEqual(0xFC00, half(double.NegativeInfinity).value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void half_from_double_construction_signed_zero()
         {
             TestUtils.AreEqual(0x8000, half(TestUtils.SignedDoubleZero()).value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half2_from_double2_construction()
         {
             half2 h0 = half2(double2(0.0, 2.98e-08));
@@ -196,7 +196,7 @@ public static void half2_from_double2_construction()
             TestUtils.AreEqual(uint2(0xFC00, 0x0000), uint2(h7.x.value, h7.y.value));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void half2_from_double2_construction_signed_zero()
         {
@@ -204,7 +204,7 @@ public static void half2_from_double2_construction_signed_zero()
             TestUtils.AreEqual(uint2(0x8000, 0x8000), uint2(h0.x.value, h0.y.value));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half3_from_double3_construction()
         {
             half3 h0 = half3(double3(0.0, 2.98e-08, 5.96046448e-08));
@@ -221,7 +221,7 @@ public static void half3_from_double3_construction()
             TestUtils.AreEqual(uint3(0xFC00, 0xFC00, 0x0000), uint3(h4.x.value, h4.y.value, h4.z.value));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void half3_from_double3_construction_signed_zero()
         {
@@ -229,7 +229,7 @@ public static void half3_from_double3_construction_signed_zero()
             TestUtils.AreEqual(uint3(0x8000, 0x8000, 0x8000), uint3(h0.x.value, h0.y.value, h0.z.value));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half4_from_double4_construction()
         {
             half4 h0 = half4(double4(0.0, 2.98e-08, 5.96046448e-08, 123.4));
@@ -243,7 +243,7 @@ public static void half4_from_double4_construction()
             TestUtils.AreEqual(uint4(0xFC00, 0xFC00, 0xFC00, 0x0000), uint4(h3.x.value, h3.y.value, h3.z.value, h3.w.value));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void half4_from_double4_construction_signed_zero()
         {
@@ -251,7 +251,7 @@ public static void half4_from_double4_construction_signed_zero()
             TestUtils.AreEqual(uint4(0x8000, 0x8000, 0x8000, 0x8000), uint4(h0.x.value, h0.y.value, h0.z.value, h0.w.value));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half_to_float()
         {
             TestUtils.AreEqual(0x00000000, asuint(new half { value = 0x0000 }));
@@ -269,7 +269,7 @@ public static void half_to_float()
             TestUtils.AreEqual(true, isnan(new half { value = 0xFC01 }));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half2_to_float2()
         {
             half2 h0; h0.x.value = 0x0000; h0.y.value = 0x0203;
@@ -293,7 +293,7 @@ public static void half2_to_float2()
             TestUtils.AreEqual(true, all(isnan(h7)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half3_to_float3()
         {
             half3 h0; h0.x.value = 0x0000; h0.y.value = 0x0203; h0.z.value = 0x4321;
@@ -313,7 +313,7 @@ public static void half3_to_float3()
             TestUtils.AreEqual(true, all(isnan(h5)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half4_to_float4()
         {
             half4 h0; h0.x.value = 0x0000; h0.y.value = 0x0203; h0.z.value = 0x4321; h0.w.value = 0x7BFF;
@@ -334,7 +334,7 @@ public static void half4_to_float4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half_to_double()
         {
             TestUtils.AreEqual(0x0000000000000000u, asulong((double)new half { value = 0x0000 }));
@@ -353,14 +353,14 @@ public static void half_to_double()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half_from_float_explicit_conversion()
         {
             half h = (half)123.4f;
             TestUtils.AreEqual(0x57B6, h.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half2_from_float2_explicit_conversion()
         {
             half2 h = (half2)float2(123.4f, 5.96046448e-08f);
@@ -368,7 +368,7 @@ public static void half2_from_float2_explicit_conversion()
             TestUtils.AreEqual(0x0001, h.y.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half3_from_float3_explicit_conversion()
         {
             half3 h = (half3)float3(123.4f, 5.96046448e-08f, -65504.0f);
@@ -377,7 +377,7 @@ public static void half3_from_float3_explicit_conversion()
             TestUtils.AreEqual(0xFBFF, h.z.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half4_from_float4_explicit_conversion()
         {
             half4 h = (half4)float4(123.4f, 5.96046448e-08f, -65504.0f, float.PositiveInfinity);
@@ -387,7 +387,7 @@ public static void half4_from_float4_explicit_conversion()
             TestUtils.AreEqual(0x7C00, h.w.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half_from_double_explicit_conversion()
         {
             half h = (half)123.4;
@@ -395,7 +395,7 @@ public static void half_from_double_explicit_conversion()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half_to_float_implicit_conversion()
         {
             half h; h.value = 0x0203;
@@ -403,7 +403,7 @@ public static void half_to_float_implicit_conversion()
             TestUtils.AreEqual(0x3800C000, asuint(f));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half2_to_float2_implicit_conversion()
         {
             half2 h; h.x.value = 0x0203;    h.y.value = 0x8203;
@@ -412,7 +412,7 @@ public static void half2_to_float2_implicit_conversion()
             TestUtils.AreEqual(0xB800C000, asuint(f.y));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half3_to_float3_implicit_conversion()
         {
             half3 h; h.x.value = 0x0203; h.y.value = 0x8203; h.z.value = 0x7BFF;
@@ -422,7 +422,7 @@ public static void half3_to_float3_implicit_conversion()
             TestUtils.AreEqual(0x477FE000, asuint(f.z));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half4_to_float4_implicit_conversion()
         {
             half4 h; h.x.value = 0x0203; h.y.value = 0x8203; h.z.value = 0x7BFF; h.w.value = 0x7C00;
@@ -433,7 +433,7 @@ public static void half4_to_float4_implicit_conversion()
             TestUtils.AreEqual(0x7F800000, asuint(f.w));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half_to_double_implicit_conversion()
         {
             half h; h.value = 0x0203;
@@ -442,33 +442,33 @@ public static void half_to_double_implicit_conversion()
             TestUtils.AreEqual(0x3F00180000000000u, asulong(f));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half_minvalue()
         {
             half min = new half(half.MinValue);
             TestUtils.AreEqual(0xfbff, min.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half_maxvalue()
         {
             half max = new half(half.MaxValue);
             TestUtils.AreEqual(0x7bff, max.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half_minvalueashalf()
         {
             TestUtils.AreEqual(0xfbff, half.MinValueAsHalf.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half_maxvalueashalf()
         {
             TestUtils.AreEqual(0x7bff, half.MaxValueAsHalf.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half2_minvalue()
         {
             half2 min = half.MinValueAsHalf;
@@ -476,7 +476,7 @@ public static void half2_minvalue()
             TestUtils.AreEqual(0xfbff, min.y.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half2_maxvalue()
         {
             half2 max = half.MaxValueAsHalf;
@@ -484,7 +484,7 @@ public static void half2_maxvalue()
             TestUtils.AreEqual(0x7bff, max.y.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half3_minvalue()
         {
             half3 min = half.MinValueAsHalf;
@@ -493,7 +493,7 @@ public static void half3_minvalue()
             TestUtils.AreEqual(0xfbff, min.z.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half3_maxvalue()
         {
             half3 max = half.MaxValueAsHalf;
@@ -502,7 +502,7 @@ public static void half3_maxvalue()
             TestUtils.AreEqual(0x7bff, max.z.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half4_minvalue()
         {
             half4 min = half.MinValueAsHalf;
@@ -512,7 +512,7 @@ public static void half4_minvalue()
             TestUtils.AreEqual(0xfbff, min.w.value);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void half4_maxvalue()
         {
             half4 max = half.MaxValueAsHalf;
diff --git a/src/Tests/Tests/Shared/TestInt2.gen.cs b/src/Tests/Tests/Shared/TestInt2.gen.cs
index 6196c993..75f6aba0 100644
--- a/src/Tests/Tests/Shared/TestInt2.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt2.gen.cs
@@ -15,14 +15,14 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_zero()
         {
             TestUtils.AreEqual(0, int2.zero.x);
             TestUtils.AreEqual(0, int2.zero.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_constructor()
         {
             int2 a = new int2(1, 2);
@@ -30,7 +30,7 @@ public static void int2_constructor()
             TestUtils.AreEqual(2, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_scalar_constructor()
         {
             int2 a = new int2(17);
@@ -38,7 +38,7 @@ public static void int2_scalar_constructor()
             TestUtils.AreEqual(17, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_static_constructor()
         {
             int2 a = int2(1, 2);
@@ -46,7 +46,7 @@ public static void int2_static_constructor()
             TestUtils.AreEqual(2, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_static_scalar_constructor()
         {
             int2 a = int2(17);
@@ -54,7 +54,7 @@ public static void int2_static_scalar_constructor()
             TestUtils.AreEqual(17, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_equal_wide_wide()
         {
             int2 a0 = int2(2105871082, 35218899);
@@ -78,7 +78,7 @@ public static void int2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_equal_wide_scalar()
         {
             int2 a0 = int2(437822262, 2020661134);
@@ -102,7 +102,7 @@ public static void int2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -126,7 +126,7 @@ public static void int2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_not_equal_wide_wide()
         {
             int2 a0 = int2(1977284100, 1293292704);
@@ -150,7 +150,7 @@ public static void int2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_not_equal_wide_scalar()
         {
             int2 a0 = int2(1038269360, 1427812625);
@@ -174,7 +174,7 @@ public static void int2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -198,7 +198,7 @@ public static void int2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_less_wide_wide()
         {
             int2 a0 = int2(1486550609, 1779244308);
@@ -222,7 +222,7 @@ public static void int2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_less_wide_scalar()
         {
             int2 a0 = int2(796797557, 670113454);
@@ -246,7 +246,7 @@ public static void int2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -270,7 +270,7 @@ public static void int2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_greater_wide_wide()
         {
             int2 a0 = int2(2087717754, 1725569452);
@@ -294,7 +294,7 @@ public static void int2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_greater_wide_scalar()
         {
             int2 a0 = int2(1208626274, 239697208);
@@ -318,7 +318,7 @@ public static void int2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -342,7 +342,7 @@ public static void int2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_less_equal_wide_wide()
         {
             int2 a0 = int2(154092149, 1515170149);
@@ -366,7 +366,7 @@ public static void int2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_less_equal_wide_scalar()
         {
             int2 a0 = int2(1479531977, 1427983411);
@@ -390,7 +390,7 @@ public static void int2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -414,7 +414,7 @@ public static void int2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_greater_equal_wide_wide()
         {
             int2 a0 = int2(8538378, 2131749726);
@@ -438,7 +438,7 @@ public static void int2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_greater_equal_wide_scalar()
         {
             int2 a0 = int2(2049236663, 182691143);
@@ -462,7 +462,7 @@ public static void int2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -486,7 +486,7 @@ public static void int2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_add_wide_wide()
         {
             int2 a0 = int2(2135171378, 21433296);
@@ -510,7 +510,7 @@ public static void int2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_add_wide_scalar()
         {
             int2 a0 = int2(665815972, 1783729250);
@@ -534,7 +534,7 @@ public static void int2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -558,7 +558,7 @@ public static void int2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_sub_wide_wide()
         {
             int2 a0 = int2(1410318491, 1097280168);
@@ -582,7 +582,7 @@ public static void int2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_sub_wide_scalar()
         {
             int2 a0 = int2(1508669340, 1594795463);
@@ -606,7 +606,7 @@ public static void int2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -630,7 +630,7 @@ public static void int2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_mul_wide_wide()
         {
             int2 a0 = int2(61417577, 219585476);
@@ -654,7 +654,7 @@ public static void int2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_mul_wide_scalar()
         {
             int2 a0 = int2(871746615, 492532311);
@@ -678,7 +678,7 @@ public static void int2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -702,7 +702,7 @@ public static void int2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_div_wide_wide()
         {
             int2 a0 = int2(333171510, 858154903);
@@ -726,7 +726,7 @@ public static void int2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_div_wide_scalar()
         {
             int2 a0 = int2(1433072926, 1073958635);
@@ -750,7 +750,7 @@ public static void int2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -774,7 +774,7 @@ public static void int2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_mod_wide_wide()
         {
             int2 a0 = int2(258342924, 1454754891);
@@ -798,7 +798,7 @@ public static void int2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_mod_wide_scalar()
         {
             int2 a0 = int2(560988938, 629524514);
@@ -822,7 +822,7 @@ public static void int2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -846,7 +846,7 @@ public static void int2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_plus()
         {
             int2 a0 = int2(195392567, 222719748);
@@ -866,7 +866,7 @@ public static void int2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_neg()
         {
             int2 a0 = int2(1385088677, 94114564);
@@ -886,7 +886,7 @@ public static void int2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_prefix_inc()
         {
             int2 a0 = int2(780471723, 954741756);
@@ -906,7 +906,7 @@ public static void int2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_postfix_inc()
         {
             int2 a0 = int2(241865086, 2145821641);
@@ -926,7 +926,7 @@ public static void int2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_prefix_dec()
         {
             int2 a0 = int2(1331961415, 1612382200);
@@ -946,7 +946,7 @@ public static void int2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_postfix_dec()
         {
             int2 a0 = int2(1870005937, 1708534798);
@@ -966,7 +966,7 @@ public static void int2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_bitwise_and_wide_wide()
         {
             int2 a0 = int2(1055241304, 859321394);
@@ -990,7 +990,7 @@ public static void int2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_bitwise_and_wide_scalar()
         {
             int2 a0 = int2(1513158868, 284695609);
@@ -1014,7 +1014,7 @@ public static void int2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1038,7 +1038,7 @@ public static void int2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_bitwise_or_wide_wide()
         {
             int2 a0 = int2(1920951869, 1750772852);
@@ -1062,7 +1062,7 @@ public static void int2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_bitwise_or_wide_scalar()
         {
             int2 a0 = int2(1295304853, 1307252624);
@@ -1086,7 +1086,7 @@ public static void int2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1110,7 +1110,7 @@ public static void int2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_bitwise_xor_wide_wide()
         {
             int2 a0 = int2(1843655608, 362425681);
@@ -1134,7 +1134,7 @@ public static void int2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_bitwise_xor_wide_scalar()
         {
             int2 a0 = int2(169345668, 176087064);
@@ -1158,7 +1158,7 @@ public static void int2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1182,7 +1182,7 @@ public static void int2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_left_shift()
         {
             int2 a0 = int2(1129100049, 829482269);
@@ -1206,7 +1206,7 @@ public static void int2_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_right_shift()
         {
             int2 a0 = int2(809126085, 908563670);
@@ -1230,7 +1230,7 @@ public static void int2_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_operator_bitwise_not()
         {
             int2 a0 = int2(111796841, 603562399);
@@ -1250,7 +1250,7 @@ public static void int2_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_shuffle_result_1()
         {
             int2 a = int2(0, 1);
@@ -1262,7 +1262,7 @@ public static void int2_shuffle_result_1()
             TestUtils.AreEqual((3), shuffle(a, b, ShuffleComponent.RightY));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_shuffle_result_2()
         {
             int2 a = int2(0, 1);
@@ -1286,7 +1286,7 @@ public static void int2_shuffle_result_2()
             TestUtils.AreEqual(int2(3, 3), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_shuffle_result_3()
         {
             int2 a = int2(0, 1);
@@ -1310,7 +1310,7 @@ public static void int2_shuffle_result_3()
             TestUtils.AreEqual(int3(3, 1, 1), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_shuffle_result_4()
         {
             int2 a = int2(0, 1);
diff --git a/src/Tests/Tests/Shared/TestInt2x2.gen.cs b/src/Tests/Tests/Shared/TestInt2x2.gen.cs
index a99dd57e..754451d3 100644
--- a/src/Tests/Tests/Shared/TestInt2x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt2x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt2x2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_zero()
         {
             TestUtils.AreEqual(0, int2x2.zero.c0.x);
@@ -24,7 +24,7 @@ public static void int2x2_zero()
             TestUtils.AreEqual(0, int2x2.zero.c1.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_identity()
         {
             TestUtils.AreEqual(1, int2x2.identity.c0.x);
@@ -33,7 +33,7 @@ public static void int2x2_identity()
             TestUtils.AreEqual(1, int2x2.identity.c1.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_equal_wide_wide()
         {
             int2x2 a0 = int2x2(2105871082, 35218899, 1550755093, 764676020);
@@ -57,7 +57,7 @@ public static void int2x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_equal_wide_scalar()
         {
             int2x2 a0 = int2x2(437822262, 2020661134, 541786900, 853113810);
@@ -81,7 +81,7 @@ public static void int2x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -105,7 +105,7 @@ public static void int2x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_not_equal_wide_wide()
         {
             int2x2 a0 = int2x2(1977284100, 1293292704, 1547283851, 422428953);
@@ -129,7 +129,7 @@ public static void int2x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_not_equal_wide_scalar()
         {
             int2x2 a0 = int2x2(1038269360, 1427812625, 103361237, 1347017023);
@@ -153,7 +153,7 @@ public static void int2x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -177,7 +177,7 @@ public static void int2x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_less_wide_wide()
         {
             int2x2 a0 = int2x2(1486550609, 1779244308, 1602148045, 1614085440);
@@ -201,7 +201,7 @@ public static void int2x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_less_wide_scalar()
         {
             int2x2 a0 = int2x2(796797557, 670113454, 933579492, 278884514);
@@ -225,7 +225,7 @@ public static void int2x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -249,7 +249,7 @@ public static void int2x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_greater_wide_wide()
         {
             int2x2 a0 = int2x2(2087717754, 1725569452, 1298066182, 1693943616);
@@ -273,7 +273,7 @@ public static void int2x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_greater_wide_scalar()
         {
             int2x2 a0 = int2x2(1208626274, 239697208, 1979453345, 1253474001);
@@ -297,7 +297,7 @@ public static void int2x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -321,7 +321,7 @@ public static void int2x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_less_equal_wide_wide()
         {
             int2x2 a0 = int2x2(154092149, 1515170149, 1083970332, 785807178);
@@ -345,7 +345,7 @@ public static void int2x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_less_equal_wide_scalar()
         {
             int2x2 a0 = int2x2(1479531977, 1427983411, 415250630, 1245345407);
@@ -369,7 +369,7 @@ public static void int2x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -393,7 +393,7 @@ public static void int2x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_greater_equal_wide_wide()
         {
             int2x2 a0 = int2x2(8538378, 2131749726, 265427108, 523609761);
@@ -417,7 +417,7 @@ public static void int2x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_greater_equal_wide_scalar()
         {
             int2x2 a0 = int2x2(2049236663, 182691143, 634973382, 1197012109);
@@ -441,7 +441,7 @@ public static void int2x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -465,7 +465,7 @@ public static void int2x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_add_wide_wide()
         {
             int2x2 a0 = int2x2(2135171378, 21433296, 1954723494, 683604307);
@@ -489,7 +489,7 @@ public static void int2x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_add_wide_scalar()
         {
             int2x2 a0 = int2x2(665815972, 1783729250, 1591678394, 1284528538);
@@ -513,7 +513,7 @@ public static void int2x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -537,7 +537,7 @@ public static void int2x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_sub_wide_wide()
         {
             int2x2 a0 = int2x2(1410318491, 1097280168, 1827039044, 28881338);
@@ -561,7 +561,7 @@ public static void int2x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_sub_wide_scalar()
         {
             int2x2 a0 = int2x2(1508669340, 1594795463, 266707545, 643102647);
@@ -585,7 +585,7 @@ public static void int2x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -609,7 +609,7 @@ public static void int2x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_mul_wide_wide()
         {
             int2x2 a0 = int2x2(61417577, 219585476, 1362520891, 1511084277);
@@ -633,7 +633,7 @@ public static void int2x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_mul_wide_scalar()
         {
             int2x2 a0 = int2x2(871746615, 492532311, 570557670, 2142306629);
@@ -657,7 +657,7 @@ public static void int2x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -681,7 +681,7 @@ public static void int2x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_div_wide_wide()
         {
             int2x2 a0 = int2x2(333171510, 858154903, 1181365836, 671357749);
@@ -705,7 +705,7 @@ public static void int2x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_div_wide_scalar()
         {
             int2x2 a0 = int2x2(1433072926, 1073958635, 1195142312, 536596719);
@@ -729,7 +729,7 @@ public static void int2x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -753,7 +753,7 @@ public static void int2x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_mod_wide_wide()
         {
             int2x2 a0 = int2x2(258342924, 1454754891, 723352342, 1981431473);
@@ -777,7 +777,7 @@ public static void int2x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_mod_wide_scalar()
         {
             int2x2 a0 = int2x2(560988938, 629524514, 767711194, 434281967);
@@ -801,7 +801,7 @@ public static void int2x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -825,7 +825,7 @@ public static void int2x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_plus()
         {
             int2x2 a0 = int2x2(195392567, 222719748, 1002351013, 1570765263);
@@ -845,7 +845,7 @@ public static void int2x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_neg()
         {
             int2x2 a0 = int2x2(1385088677, 94114564, 1350664872, 1458616659);
@@ -865,7 +865,7 @@ public static void int2x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_prefix_inc()
         {
             int2x2 a0 = int2x2(780471723, 954741756, 272723451, 2142862245);
@@ -885,7 +885,7 @@ public static void int2x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_postfix_inc()
         {
             int2x2 a0 = int2x2(241865086, 2145821641, 1596166022, 803592338);
@@ -905,7 +905,7 @@ public static void int2x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_prefix_dec()
         {
             int2x2 a0 = int2x2(1331961415, 1612382200, 1401591249, 2042075388);
@@ -925,7 +925,7 @@ public static void int2x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_postfix_dec()
         {
             int2x2 a0 = int2x2(1870005937, 1708534798, 704493460, 462940703);
@@ -945,7 +945,7 @@ public static void int2x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_bitwise_and_wide_wide()
         {
             int2x2 a0 = int2x2(1055241304, 859321394, 1088358961, 2090949513);
@@ -969,7 +969,7 @@ public static void int2x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_bitwise_and_wide_scalar()
         {
             int2x2 a0 = int2x2(1513158868, 284695609, 734595037, 1566510707);
@@ -993,7 +993,7 @@ public static void int2x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1017,7 +1017,7 @@ public static void int2x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_bitwise_or_wide_wide()
         {
             int2x2 a0 = int2x2(1920951869, 1750772852, 1420019191, 732977093);
@@ -1041,7 +1041,7 @@ public static void int2x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_bitwise_or_wide_scalar()
         {
             int2x2 a0 = int2x2(1295304853, 1307252624, 350194630, 1128063578);
@@ -1065,7 +1065,7 @@ public static void int2x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1089,7 +1089,7 @@ public static void int2x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_bitwise_xor_wide_wide()
         {
             int2x2 a0 = int2x2(1843655608, 362425681, 640805534, 1342040268);
@@ -1113,7 +1113,7 @@ public static void int2x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_bitwise_xor_wide_scalar()
         {
             int2x2 a0 = int2x2(169345668, 176087064, 2084362901, 1663924004);
@@ -1137,7 +1137,7 @@ public static void int2x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1161,7 +1161,7 @@ public static void int2x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_left_shift()
         {
             int2x2 a0 = int2x2(1129100049, 829482269, 1571297368, 443753193);
@@ -1185,7 +1185,7 @@ public static void int2x2_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_right_shift()
         {
             int2x2 a0 = int2x2(809126085, 908563670, 763568837, 1986717290);
@@ -1209,7 +1209,7 @@ public static void int2x2_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x2_operator_bitwise_not()
         {
             int2x2 a0 = int2x2(111796841, 603562399, 745091931, 853183268);
diff --git a/src/Tests/Tests/Shared/TestInt2x3.gen.cs b/src/Tests/Tests/Shared/TestInt2x3.gen.cs
index 95b713de..8e25e359 100644
--- a/src/Tests/Tests/Shared/TestInt2x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt2x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt2x3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_zero()
         {
             TestUtils.AreEqual(0, int2x3.zero.c0.x);
@@ -26,7 +26,7 @@ public static void int2x3_zero()
             TestUtils.AreEqual(0, int2x3.zero.c2.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_equal_wide_wide()
         {
             int2x3 a0 = int2x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098);
@@ -50,7 +50,7 @@ public static void int2x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_equal_wide_scalar()
         {
             int2x3 a0 = int2x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405);
@@ -74,7 +74,7 @@ public static void int2x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -98,7 +98,7 @@ public static void int2x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_not_equal_wide_wide()
         {
             int2x3 a0 = int2x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892);
@@ -122,7 +122,7 @@ public static void int2x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_not_equal_wide_scalar()
         {
             int2x3 a0 = int2x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802);
@@ -146,7 +146,7 @@ public static void int2x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -170,7 +170,7 @@ public static void int2x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_less_wide_wide()
         {
             int2x3 a0 = int2x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342);
@@ -194,7 +194,7 @@ public static void int2x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_less_wide_scalar()
         {
             int2x3 a0 = int2x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673);
@@ -218,7 +218,7 @@ public static void int2x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -242,7 +242,7 @@ public static void int2x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_greater_wide_wide()
         {
             int2x3 a0 = int2x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491);
@@ -266,7 +266,7 @@ public static void int2x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_greater_wide_scalar()
         {
             int2x3 a0 = int2x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635);
@@ -290,7 +290,7 @@ public static void int2x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -314,7 +314,7 @@ public static void int2x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_less_equal_wide_wide()
         {
             int2x3 a0 = int2x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627);
@@ -338,7 +338,7 @@ public static void int2x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_less_equal_wide_scalar()
         {
             int2x3 a0 = int2x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632);
@@ -362,7 +362,7 @@ public static void int2x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -386,7 +386,7 @@ public static void int2x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_greater_equal_wide_wide()
         {
             int2x3 a0 = int2x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564);
@@ -410,7 +410,7 @@ public static void int2x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_greater_equal_wide_scalar()
         {
             int2x3 a0 = int2x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469);
@@ -434,7 +434,7 @@ public static void int2x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -458,7 +458,7 @@ public static void int2x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_add_wide_wide()
         {
             int2x3 a0 = int2x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995);
@@ -482,7 +482,7 @@ public static void int2x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_add_wide_scalar()
         {
             int2x3 a0 = int2x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732);
@@ -506,7 +506,7 @@ public static void int2x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -530,7 +530,7 @@ public static void int2x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_sub_wide_wide()
         {
             int2x3 a0 = int2x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868);
@@ -554,7 +554,7 @@ public static void int2x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_sub_wide_scalar()
         {
             int2x3 a0 = int2x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328);
@@ -578,7 +578,7 @@ public static void int2x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -602,7 +602,7 @@ public static void int2x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_mul_wide_wide()
         {
             int2x3 a0 = int2x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871);
@@ -626,7 +626,7 @@ public static void int2x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_mul_wide_scalar()
         {
             int2x3 a0 = int2x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563);
@@ -650,7 +650,7 @@ public static void int2x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -674,7 +674,7 @@ public static void int2x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_div_wide_wide()
         {
             int2x3 a0 = int2x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420);
@@ -698,7 +698,7 @@ public static void int2x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_div_wide_scalar()
         {
             int2x3 a0 = int2x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346);
@@ -722,7 +722,7 @@ public static void int2x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -746,7 +746,7 @@ public static void int2x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_mod_wide_wide()
         {
             int2x3 a0 = int2x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627);
@@ -770,7 +770,7 @@ public static void int2x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_mod_wide_scalar()
         {
             int2x3 a0 = int2x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846);
@@ -794,7 +794,7 @@ public static void int2x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -818,7 +818,7 @@ public static void int2x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_plus()
         {
             int2x3 a0 = int2x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277);
@@ -838,7 +838,7 @@ public static void int2x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_neg()
         {
             int2x3 a0 = int2x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493);
@@ -858,7 +858,7 @@ public static void int2x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_prefix_inc()
         {
             int2x3 a0 = int2x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550);
@@ -878,7 +878,7 @@ public static void int2x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_postfix_inc()
         {
             int2x3 a0 = int2x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229);
@@ -898,7 +898,7 @@ public static void int2x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_prefix_dec()
         {
             int2x3 a0 = int2x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159);
@@ -918,7 +918,7 @@ public static void int2x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_postfix_dec()
         {
             int2x3 a0 = int2x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869);
@@ -938,7 +938,7 @@ public static void int2x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_bitwise_and_wide_wide()
         {
             int2x3 a0 = int2x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515);
@@ -962,7 +962,7 @@ public static void int2x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_bitwise_and_wide_scalar()
         {
             int2x3 a0 = int2x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838);
@@ -986,7 +986,7 @@ public static void int2x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1010,7 +1010,7 @@ public static void int2x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_bitwise_or_wide_wide()
         {
             int2x3 a0 = int2x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930);
@@ -1034,7 +1034,7 @@ public static void int2x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_bitwise_or_wide_scalar()
         {
             int2x3 a0 = int2x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467);
@@ -1058,7 +1058,7 @@ public static void int2x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1082,7 +1082,7 @@ public static void int2x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_bitwise_xor_wide_wide()
         {
             int2x3 a0 = int2x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850);
@@ -1106,7 +1106,7 @@ public static void int2x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_bitwise_xor_wide_scalar()
         {
             int2x3 a0 = int2x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661);
@@ -1130,7 +1130,7 @@ public static void int2x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1154,7 +1154,7 @@ public static void int2x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_left_shift()
         {
             int2x3 a0 = int2x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593);
@@ -1178,7 +1178,7 @@ public static void int2x3_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_right_shift()
         {
             int2x3 a0 = int2x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842);
@@ -1202,7 +1202,7 @@ public static void int2x3_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x3_operator_bitwise_not()
         {
             int2x3 a0 = int2x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399);
diff --git a/src/Tests/Tests/Shared/TestInt2x4.gen.cs b/src/Tests/Tests/Shared/TestInt2x4.gen.cs
index 8700456f..3fd7b8b3 100644
--- a/src/Tests/Tests/Shared/TestInt2x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt2x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt2x4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_zero()
         {
             TestUtils.AreEqual(0, int2x4.zero.c0.x);
@@ -28,7 +28,7 @@ public static void int2x4_zero()
             TestUtils.AreEqual(0, int2x4.zero.c3.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_equal_wide_wide()
         {
             int2x4 a0 = int2x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316);
@@ -52,7 +52,7 @@ public static void int2x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_equal_wide_scalar()
         {
             int2x4 a0 = int2x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849);
@@ -76,7 +76,7 @@ public static void int2x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -100,7 +100,7 @@ public static void int2x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_not_equal_wide_wide()
         {
             int2x4 a0 = int2x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074);
@@ -124,7 +124,7 @@ public static void int2x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_not_equal_wide_scalar()
         {
             int2x4 a0 = int2x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717);
@@ -148,7 +148,7 @@ public static void int2x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -172,7 +172,7 @@ public static void int2x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_less_wide_wide()
         {
             int2x4 a0 = int2x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431);
@@ -196,7 +196,7 @@ public static void int2x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_less_wide_scalar()
         {
             int2x4 a0 = int2x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600);
@@ -220,7 +220,7 @@ public static void int2x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -244,7 +244,7 @@ public static void int2x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_greater_wide_wide()
         {
             int2x4 a0 = int2x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508);
@@ -268,7 +268,7 @@ public static void int2x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_greater_wide_scalar()
         {
             int2x4 a0 = int2x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098);
@@ -292,7 +292,7 @@ public static void int2x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -316,7 +316,7 @@ public static void int2x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_less_equal_wide_wide()
         {
             int2x4 a0 = int2x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725);
@@ -340,7 +340,7 @@ public static void int2x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_less_equal_wide_scalar()
         {
             int2x4 a0 = int2x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307);
@@ -364,7 +364,7 @@ public static void int2x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -388,7 +388,7 @@ public static void int2x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_greater_equal_wide_wide()
         {
             int2x4 a0 = int2x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970);
@@ -412,7 +412,7 @@ public static void int2x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_greater_equal_wide_scalar()
         {
             int2x4 a0 = int2x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187);
@@ -436,7 +436,7 @@ public static void int2x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -460,7 +460,7 @@ public static void int2x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_add_wide_wide()
         {
             int2x4 a0 = int2x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062);
@@ -484,7 +484,7 @@ public static void int2x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_add_wide_scalar()
         {
             int2x4 a0 = int2x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017);
@@ -508,7 +508,7 @@ public static void int2x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -532,7 +532,7 @@ public static void int2x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_sub_wide_wide()
         {
             int2x4 a0 = int2x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215);
@@ -556,7 +556,7 @@ public static void int2x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_sub_wide_scalar()
         {
             int2x4 a0 = int2x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511);
@@ -580,7 +580,7 @@ public static void int2x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -604,7 +604,7 @@ public static void int2x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_mul_wide_wide()
         {
             int2x4 a0 = int2x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644);
@@ -628,7 +628,7 @@ public static void int2x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_mul_wide_scalar()
         {
             int2x4 a0 = int2x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514);
@@ -652,7 +652,7 @@ public static void int2x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -676,7 +676,7 @@ public static void int2x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_div_wide_wide()
         {
             int2x4 a0 = int2x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814);
@@ -700,7 +700,7 @@ public static void int2x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_div_wide_scalar()
         {
             int2x4 a0 = int2x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670);
@@ -724,7 +724,7 @@ public static void int2x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -748,7 +748,7 @@ public static void int2x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_mod_wide_wide()
         {
             int2x4 a0 = int2x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004);
@@ -772,7 +772,7 @@ public static void int2x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_mod_wide_scalar()
         {
             int2x4 a0 = int2x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916);
@@ -796,7 +796,7 @@ public static void int2x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -820,7 +820,7 @@ public static void int2x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_plus()
         {
             int2x4 a0 = int2x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785);
@@ -840,7 +840,7 @@ public static void int2x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_neg()
         {
             int2x4 a0 = int2x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961);
@@ -860,7 +860,7 @@ public static void int2x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_prefix_inc()
         {
             int2x4 a0 = int2x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162);
@@ -880,7 +880,7 @@ public static void int2x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_postfix_inc()
         {
             int2x4 a0 = int2x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244);
@@ -900,7 +900,7 @@ public static void int2x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_prefix_dec()
         {
             int2x4 a0 = int2x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664);
@@ -920,7 +920,7 @@ public static void int2x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_postfix_dec()
         {
             int2x4 a0 = int2x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351);
@@ -940,7 +940,7 @@ public static void int2x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_bitwise_and_wide_wide()
         {
             int2x4 a0 = int2x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753);
@@ -964,7 +964,7 @@ public static void int2x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_bitwise_and_wide_scalar()
         {
             int2x4 a0 = int2x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908);
@@ -988,7 +988,7 @@ public static void int2x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1012,7 +1012,7 @@ public static void int2x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_bitwise_or_wide_wide()
         {
             int2x4 a0 = int2x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323);
@@ -1036,7 +1036,7 @@ public static void int2x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_bitwise_or_wide_scalar()
         {
             int2x4 a0 = int2x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350);
@@ -1060,7 +1060,7 @@ public static void int2x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1084,7 +1084,7 @@ public static void int2x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_bitwise_xor_wide_wide()
         {
             int2x4 a0 = int2x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658);
@@ -1108,7 +1108,7 @@ public static void int2x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_bitwise_xor_wide_scalar()
         {
             int2x4 a0 = int2x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783);
@@ -1132,7 +1132,7 @@ public static void int2x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1156,7 +1156,7 @@ public static void int2x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_left_shift()
         {
             int2x4 a0 = int2x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862);
@@ -1180,7 +1180,7 @@ public static void int2x4_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_right_shift()
         {
             int2x4 a0 = int2x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632);
@@ -1204,7 +1204,7 @@ public static void int2x4_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2x4_operator_bitwise_not()
         {
             int2x4 a0 = int2x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135);
diff --git a/src/Tests/Tests/Shared/TestInt3.gen.cs b/src/Tests/Tests/Shared/TestInt3.gen.cs
index 92b93317..7dac46ed 100644
--- a/src/Tests/Tests/Shared/TestInt3.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_zero()
         {
             TestUtils.AreEqual(0, int3.zero.x);
@@ -23,7 +23,7 @@ public static void int3_zero()
             TestUtils.AreEqual(0, int3.zero.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_constructor()
         {
             int3 a = new int3(1, 2, 3);
@@ -32,7 +32,7 @@ public static void int3_constructor()
             TestUtils.AreEqual(3, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_scalar_constructor()
         {
             int3 a = new int3(17);
@@ -41,7 +41,7 @@ public static void int3_scalar_constructor()
             TestUtils.AreEqual(17, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_static_constructor()
         {
             int3 a = int3(1, 2, 3);
@@ -50,7 +50,7 @@ public static void int3_static_constructor()
             TestUtils.AreEqual(3, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_static_scalar_constructor()
         {
             int3 a = int3(17);
@@ -59,7 +59,7 @@ public static void int3_static_scalar_constructor()
             TestUtils.AreEqual(17, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_equal_wide_wide()
         {
             int3 a0 = int3(2105871082, 35218899, 1550755093);
@@ -83,7 +83,7 @@ public static void int3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_equal_wide_scalar()
         {
             int3 a0 = int3(437822262, 2020661134, 541786900);
@@ -107,7 +107,7 @@ public static void int3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -131,7 +131,7 @@ public static void int3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_not_equal_wide_wide()
         {
             int3 a0 = int3(1977284100, 1293292704, 1547283851);
@@ -155,7 +155,7 @@ public static void int3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_not_equal_wide_scalar()
         {
             int3 a0 = int3(1038269360, 1427812625, 103361237);
@@ -179,7 +179,7 @@ public static void int3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -203,7 +203,7 @@ public static void int3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_less_wide_wide()
         {
             int3 a0 = int3(1486550609, 1779244308, 1602148045);
@@ -227,7 +227,7 @@ public static void int3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_less_wide_scalar()
         {
             int3 a0 = int3(796797557, 670113454, 933579492);
@@ -251,7 +251,7 @@ public static void int3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -275,7 +275,7 @@ public static void int3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_greater_wide_wide()
         {
             int3 a0 = int3(2087717754, 1725569452, 1298066182);
@@ -299,7 +299,7 @@ public static void int3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_greater_wide_scalar()
         {
             int3 a0 = int3(1208626274, 239697208, 1979453345);
@@ -323,7 +323,7 @@ public static void int3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -347,7 +347,7 @@ public static void int3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_less_equal_wide_wide()
         {
             int3 a0 = int3(154092149, 1515170149, 1083970332);
@@ -371,7 +371,7 @@ public static void int3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_less_equal_wide_scalar()
         {
             int3 a0 = int3(1479531977, 1427983411, 415250630);
@@ -395,7 +395,7 @@ public static void int3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -419,7 +419,7 @@ public static void int3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_greater_equal_wide_wide()
         {
             int3 a0 = int3(8538378, 2131749726, 265427108);
@@ -443,7 +443,7 @@ public static void int3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_greater_equal_wide_scalar()
         {
             int3 a0 = int3(2049236663, 182691143, 634973382);
@@ -467,7 +467,7 @@ public static void int3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -491,7 +491,7 @@ public static void int3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_add_wide_wide()
         {
             int3 a0 = int3(2135171378, 21433296, 1954723494);
@@ -515,7 +515,7 @@ public static void int3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_add_wide_scalar()
         {
             int3 a0 = int3(665815972, 1783729250, 1591678394);
@@ -539,7 +539,7 @@ public static void int3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -563,7 +563,7 @@ public static void int3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_sub_wide_wide()
         {
             int3 a0 = int3(1410318491, 1097280168, 1827039044);
@@ -587,7 +587,7 @@ public static void int3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_sub_wide_scalar()
         {
             int3 a0 = int3(1508669340, 1594795463, 266707545);
@@ -611,7 +611,7 @@ public static void int3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -635,7 +635,7 @@ public static void int3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_mul_wide_wide()
         {
             int3 a0 = int3(61417577, 219585476, 1362520891);
@@ -659,7 +659,7 @@ public static void int3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_mul_wide_scalar()
         {
             int3 a0 = int3(871746615, 492532311, 570557670);
@@ -683,7 +683,7 @@ public static void int3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -707,7 +707,7 @@ public static void int3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_div_wide_wide()
         {
             int3 a0 = int3(333171510, 858154903, 1181365836);
@@ -731,7 +731,7 @@ public static void int3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_div_wide_scalar()
         {
             int3 a0 = int3(1433072926, 1073958635, 1195142312);
@@ -755,7 +755,7 @@ public static void int3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -779,7 +779,7 @@ public static void int3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_mod_wide_wide()
         {
             int3 a0 = int3(258342924, 1454754891, 723352342);
@@ -803,7 +803,7 @@ public static void int3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_mod_wide_scalar()
         {
             int3 a0 = int3(560988938, 629524514, 767711194);
@@ -827,7 +827,7 @@ public static void int3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -851,7 +851,7 @@ public static void int3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_plus()
         {
             int3 a0 = int3(195392567, 222719748, 1002351013);
@@ -871,7 +871,7 @@ public static void int3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_neg()
         {
             int3 a0 = int3(1385088677, 94114564, 1350664872);
@@ -891,7 +891,7 @@ public static void int3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_prefix_inc()
         {
             int3 a0 = int3(780471723, 954741756, 272723451);
@@ -911,7 +911,7 @@ public static void int3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_postfix_inc()
         {
             int3 a0 = int3(241865086, 2145821641, 1596166022);
@@ -931,7 +931,7 @@ public static void int3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_prefix_dec()
         {
             int3 a0 = int3(1331961415, 1612382200, 1401591249);
@@ -951,7 +951,7 @@ public static void int3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_postfix_dec()
         {
             int3 a0 = int3(1870005937, 1708534798, 704493460);
@@ -971,7 +971,7 @@ public static void int3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_bitwise_and_wide_wide()
         {
             int3 a0 = int3(1055241304, 859321394, 1088358961);
@@ -995,7 +995,7 @@ public static void int3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_bitwise_and_wide_scalar()
         {
             int3 a0 = int3(1513158868, 284695609, 734595037);
@@ -1019,7 +1019,7 @@ public static void int3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1043,7 +1043,7 @@ public static void int3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_bitwise_or_wide_wide()
         {
             int3 a0 = int3(1920951869, 1750772852, 1420019191);
@@ -1067,7 +1067,7 @@ public static void int3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_bitwise_or_wide_scalar()
         {
             int3 a0 = int3(1295304853, 1307252624, 350194630);
@@ -1091,7 +1091,7 @@ public static void int3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1115,7 +1115,7 @@ public static void int3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_bitwise_xor_wide_wide()
         {
             int3 a0 = int3(1843655608, 362425681, 640805534);
@@ -1139,7 +1139,7 @@ public static void int3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_bitwise_xor_wide_scalar()
         {
             int3 a0 = int3(169345668, 176087064, 2084362901);
@@ -1163,7 +1163,7 @@ public static void int3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1187,7 +1187,7 @@ public static void int3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_left_shift()
         {
             int3 a0 = int3(1129100049, 829482269, 1571297368);
@@ -1211,7 +1211,7 @@ public static void int3_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_right_shift()
         {
             int3 a0 = int3(809126085, 908563670, 763568837);
@@ -1235,7 +1235,7 @@ public static void int3_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_operator_bitwise_not()
         {
             int3 a0 = int3(111796841, 603562399, 745091931);
@@ -1255,7 +1255,7 @@ public static void int3_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_shuffle_result_1()
         {
             int3 a = int3(0, 1, 2);
@@ -1269,7 +1269,7 @@ public static void int3_shuffle_result_1()
             TestUtils.AreEqual((5), shuffle(a, b, ShuffleComponent.RightZ));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_shuffle_result_2()
         {
             int3 a = int3(0, 1, 2);
@@ -1293,7 +1293,7 @@ public static void int3_shuffle_result_2()
             TestUtils.AreEqual(int2(1, 2), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_shuffle_result_3()
         {
             int3 a = int3(0, 1, 2);
@@ -1317,7 +1317,7 @@ public static void int3_shuffle_result_3()
             TestUtils.AreEqual(int3(4, 0, 5), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_shuffle_result_4()
         {
             int3 a = int3(0, 1, 2);
diff --git a/src/Tests/Tests/Shared/TestInt3x2.gen.cs b/src/Tests/Tests/Shared/TestInt3x2.gen.cs
index 769f2d00..db159df9 100644
--- a/src/Tests/Tests/Shared/TestInt3x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt3x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt3x2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_zero()
         {
             TestUtils.AreEqual(0, int3x2.zero.c0.x);
@@ -26,7 +26,7 @@ public static void int3x2_zero()
             TestUtils.AreEqual(0, int3x2.zero.c1.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_equal_wide_wide()
         {
             int3x2 a0 = int3x2(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098);
@@ -50,7 +50,7 @@ public static void int3x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_equal_wide_scalar()
         {
             int3x2 a0 = int3x2(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405);
@@ -74,7 +74,7 @@ public static void int3x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -98,7 +98,7 @@ public static void int3x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_not_equal_wide_wide()
         {
             int3x2 a0 = int3x2(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892);
@@ -122,7 +122,7 @@ public static void int3x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_not_equal_wide_scalar()
         {
             int3x2 a0 = int3x2(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802);
@@ -146,7 +146,7 @@ public static void int3x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -170,7 +170,7 @@ public static void int3x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_less_wide_wide()
         {
             int3x2 a0 = int3x2(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342);
@@ -194,7 +194,7 @@ public static void int3x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_less_wide_scalar()
         {
             int3x2 a0 = int3x2(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673);
@@ -218,7 +218,7 @@ public static void int3x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -242,7 +242,7 @@ public static void int3x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_greater_wide_wide()
         {
             int3x2 a0 = int3x2(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491);
@@ -266,7 +266,7 @@ public static void int3x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_greater_wide_scalar()
         {
             int3x2 a0 = int3x2(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635);
@@ -290,7 +290,7 @@ public static void int3x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -314,7 +314,7 @@ public static void int3x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_less_equal_wide_wide()
         {
             int3x2 a0 = int3x2(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627);
@@ -338,7 +338,7 @@ public static void int3x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_less_equal_wide_scalar()
         {
             int3x2 a0 = int3x2(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632);
@@ -362,7 +362,7 @@ public static void int3x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -386,7 +386,7 @@ public static void int3x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_greater_equal_wide_wide()
         {
             int3x2 a0 = int3x2(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564);
@@ -410,7 +410,7 @@ public static void int3x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_greater_equal_wide_scalar()
         {
             int3x2 a0 = int3x2(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469);
@@ -434,7 +434,7 @@ public static void int3x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -458,7 +458,7 @@ public static void int3x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_add_wide_wide()
         {
             int3x2 a0 = int3x2(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995);
@@ -482,7 +482,7 @@ public static void int3x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_add_wide_scalar()
         {
             int3x2 a0 = int3x2(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732);
@@ -506,7 +506,7 @@ public static void int3x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -530,7 +530,7 @@ public static void int3x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_sub_wide_wide()
         {
             int3x2 a0 = int3x2(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868);
@@ -554,7 +554,7 @@ public static void int3x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_sub_wide_scalar()
         {
             int3x2 a0 = int3x2(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328);
@@ -578,7 +578,7 @@ public static void int3x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -602,7 +602,7 @@ public static void int3x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_mul_wide_wide()
         {
             int3x2 a0 = int3x2(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871);
@@ -626,7 +626,7 @@ public static void int3x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_mul_wide_scalar()
         {
             int3x2 a0 = int3x2(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563);
@@ -650,7 +650,7 @@ public static void int3x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -674,7 +674,7 @@ public static void int3x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_div_wide_wide()
         {
             int3x2 a0 = int3x2(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420);
@@ -698,7 +698,7 @@ public static void int3x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_div_wide_scalar()
         {
             int3x2 a0 = int3x2(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346);
@@ -722,7 +722,7 @@ public static void int3x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -746,7 +746,7 @@ public static void int3x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_mod_wide_wide()
         {
             int3x2 a0 = int3x2(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627);
@@ -770,7 +770,7 @@ public static void int3x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_mod_wide_scalar()
         {
             int3x2 a0 = int3x2(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846);
@@ -794,7 +794,7 @@ public static void int3x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -818,7 +818,7 @@ public static void int3x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_plus()
         {
             int3x2 a0 = int3x2(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277);
@@ -838,7 +838,7 @@ public static void int3x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_neg()
         {
             int3x2 a0 = int3x2(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493);
@@ -858,7 +858,7 @@ public static void int3x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_prefix_inc()
         {
             int3x2 a0 = int3x2(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550);
@@ -878,7 +878,7 @@ public static void int3x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_postfix_inc()
         {
             int3x2 a0 = int3x2(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229);
@@ -898,7 +898,7 @@ public static void int3x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_prefix_dec()
         {
             int3x2 a0 = int3x2(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159);
@@ -918,7 +918,7 @@ public static void int3x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_postfix_dec()
         {
             int3x2 a0 = int3x2(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869);
@@ -938,7 +938,7 @@ public static void int3x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_bitwise_and_wide_wide()
         {
             int3x2 a0 = int3x2(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515);
@@ -962,7 +962,7 @@ public static void int3x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_bitwise_and_wide_scalar()
         {
             int3x2 a0 = int3x2(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838);
@@ -986,7 +986,7 @@ public static void int3x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1010,7 +1010,7 @@ public static void int3x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_bitwise_or_wide_wide()
         {
             int3x2 a0 = int3x2(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930);
@@ -1034,7 +1034,7 @@ public static void int3x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_bitwise_or_wide_scalar()
         {
             int3x2 a0 = int3x2(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467);
@@ -1058,7 +1058,7 @@ public static void int3x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1082,7 +1082,7 @@ public static void int3x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_bitwise_xor_wide_wide()
         {
             int3x2 a0 = int3x2(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850);
@@ -1106,7 +1106,7 @@ public static void int3x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_bitwise_xor_wide_scalar()
         {
             int3x2 a0 = int3x2(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661);
@@ -1130,7 +1130,7 @@ public static void int3x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1154,7 +1154,7 @@ public static void int3x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_left_shift()
         {
             int3x2 a0 = int3x2(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593);
@@ -1178,7 +1178,7 @@ public static void int3x2_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_right_shift()
         {
             int3x2 a0 = int3x2(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842);
@@ -1202,7 +1202,7 @@ public static void int3x2_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x2_operator_bitwise_not()
         {
             int3x2 a0 = int3x2(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399);
diff --git a/src/Tests/Tests/Shared/TestInt3x3.gen.cs b/src/Tests/Tests/Shared/TestInt3x3.gen.cs
index c2a99c4f..5d82264a 100644
--- a/src/Tests/Tests/Shared/TestInt3x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt3x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt3x3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_zero()
         {
             TestUtils.AreEqual(0, int3x3.zero.c0.x);
@@ -29,7 +29,7 @@ public static void int3x3_zero()
             TestUtils.AreEqual(0, int3x3.zero.c2.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_identity()
         {
             TestUtils.AreEqual(1, int3x3.identity.c0.x);
@@ -43,7 +43,7 @@ public static void int3x3_identity()
             TestUtils.AreEqual(1, int3x3.identity.c2.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_equal_wide_wide()
         {
             int3x3 a0 = int3x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367);
@@ -67,7 +67,7 @@ public static void int3x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_equal_wide_scalar()
         {
             int3x3 a0 = int3x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998);
@@ -91,7 +91,7 @@ public static void int3x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -115,7 +115,7 @@ public static void int3x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_not_equal_wide_wide()
         {
             int3x3 a0 = int3x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678);
@@ -139,7 +139,7 @@ public static void int3x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_not_equal_wide_scalar()
         {
             int3x3 a0 = int3x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423);
@@ -163,7 +163,7 @@ public static void int3x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -187,7 +187,7 @@ public static void int3x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_less_wide_wide()
         {
             int3x3 a0 = int3x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312);
@@ -211,7 +211,7 @@ public static void int3x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_less_wide_scalar()
         {
             int3x3 a0 = int3x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597);
@@ -235,7 +235,7 @@ public static void int3x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -259,7 +259,7 @@ public static void int3x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_greater_wide_wide()
         {
             int3x3 a0 = int3x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133);
@@ -283,7 +283,7 @@ public static void int3x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_greater_wide_scalar()
         {
             int3x3 a0 = int3x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855);
@@ -307,7 +307,7 @@ public static void int3x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -331,7 +331,7 @@ public static void int3x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_less_equal_wide_wide()
         {
             int3x3 a0 = int3x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541);
@@ -355,7 +355,7 @@ public static void int3x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_less_equal_wide_scalar()
         {
             int3x3 a0 = int3x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375);
@@ -379,7 +379,7 @@ public static void int3x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -403,7 +403,7 @@ public static void int3x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_greater_equal_wide_wide()
         {
             int3x3 a0 = int3x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826);
@@ -427,7 +427,7 @@ public static void int3x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_greater_equal_wide_scalar()
         {
             int3x3 a0 = int3x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669);
@@ -451,7 +451,7 @@ public static void int3x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -475,7 +475,7 @@ public static void int3x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_add_wide_wide()
         {
             int3x3 a0 = int3x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600);
@@ -499,7 +499,7 @@ public static void int3x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_add_wide_scalar()
         {
             int3x3 a0 = int3x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008);
@@ -523,7 +523,7 @@ public static void int3x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -547,7 +547,7 @@ public static void int3x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_sub_wide_wide()
         {
             int3x3 a0 = int3x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315);
@@ -571,7 +571,7 @@ public static void int3x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_sub_wide_scalar()
         {
             int3x3 a0 = int3x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113);
@@ -595,7 +595,7 @@ public static void int3x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -619,7 +619,7 @@ public static void int3x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_mul_wide_wide()
         {
             int3x3 a0 = int3x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583);
@@ -643,7 +643,7 @@ public static void int3x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_mul_wide_scalar()
         {
             int3x3 a0 = int3x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059);
@@ -667,7 +667,7 @@ public static void int3x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -691,7 +691,7 @@ public static void int3x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_div_wide_wide()
         {
             int3x3 a0 = int3x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195);
@@ -715,7 +715,7 @@ public static void int3x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_div_wide_scalar()
         {
             int3x3 a0 = int3x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136);
@@ -739,7 +739,7 @@ public static void int3x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -763,7 +763,7 @@ public static void int3x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_mod_wide_wide()
         {
             int3x3 a0 = int3x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101);
@@ -787,7 +787,7 @@ public static void int3x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_mod_wide_scalar()
         {
             int3x3 a0 = int3x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144);
@@ -811,7 +811,7 @@ public static void int3x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -835,7 +835,7 @@ public static void int3x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_plus()
         {
             int3x3 a0 = int3x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671);
@@ -855,7 +855,7 @@ public static void int3x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_neg()
         {
             int3x3 a0 = int3x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525);
@@ -875,7 +875,7 @@ public static void int3x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_prefix_inc()
         {
             int3x3 a0 = int3x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994);
@@ -895,7 +895,7 @@ public static void int3x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_postfix_inc()
         {
             int3x3 a0 = int3x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247);
@@ -915,7 +915,7 @@ public static void int3x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_prefix_dec()
         {
             int3x3 a0 = int3x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745);
@@ -935,7 +935,7 @@ public static void int3x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_postfix_dec()
         {
             int3x3 a0 = int3x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889);
@@ -955,7 +955,7 @@ public static void int3x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_bitwise_and_wide_wide()
         {
             int3x3 a0 = int3x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656);
@@ -979,7 +979,7 @@ public static void int3x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_bitwise_and_wide_scalar()
         {
             int3x3 a0 = int3x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263);
@@ -1003,7 +1003,7 @@ public static void int3x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1027,7 +1027,7 @@ public static void int3x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_bitwise_or_wide_wide()
         {
             int3x3 a0 = int3x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869);
@@ -1051,7 +1051,7 @@ public static void int3x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_bitwise_or_wide_scalar()
         {
             int3x3 a0 = int3x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307);
@@ -1075,7 +1075,7 @@ public static void int3x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1099,7 +1099,7 @@ public static void int3x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_bitwise_xor_wide_wide()
         {
             int3x3 a0 = int3x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251);
@@ -1123,7 +1123,7 @@ public static void int3x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_bitwise_xor_wide_scalar()
         {
             int3x3 a0 = int3x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873);
@@ -1147,7 +1147,7 @@ public static void int3x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1171,7 +1171,7 @@ public static void int3x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_left_shift()
         {
             int3x3 a0 = int3x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727);
@@ -1195,7 +1195,7 @@ public static void int3x3_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_right_shift()
         {
             int3x3 a0 = int3x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393);
@@ -1219,7 +1219,7 @@ public static void int3x3_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x3_operator_bitwise_not()
         {
             int3x3 a0 = int3x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628);
diff --git a/src/Tests/Tests/Shared/TestInt3x4.gen.cs b/src/Tests/Tests/Shared/TestInt3x4.gen.cs
index 449377a8..f9b43392 100644
--- a/src/Tests/Tests/Shared/TestInt3x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt3x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt3x4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_zero()
         {
             TestUtils.AreEqual(0, int3x4.zero.c0.x);
@@ -32,7 +32,7 @@ public static void int3x4_zero()
             TestUtils.AreEqual(0, int3x4.zero.c3.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_equal_wide_wide()
         {
             int3x4 a0 = int3x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837);
@@ -56,7 +56,7 @@ public static void int3x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_equal_wide_scalar()
         {
             int3x4 a0 = int3x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137);
@@ -80,7 +80,7 @@ public static void int3x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -104,7 +104,7 @@ public static void int3x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_not_equal_wide_wide()
         {
             int3x4 a0 = int3x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545);
@@ -128,7 +128,7 @@ public static void int3x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_not_equal_wide_scalar()
         {
             int3x4 a0 = int3x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494);
@@ -152,7 +152,7 @@ public static void int3x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -176,7 +176,7 @@ public static void int3x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_less_wide_wide()
         {
             int3x4 a0 = int3x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069);
@@ -200,7 +200,7 @@ public static void int3x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_less_wide_scalar()
         {
             int3x4 a0 = int3x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417);
@@ -224,7 +224,7 @@ public static void int3x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -248,7 +248,7 @@ public static void int3x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_greater_wide_wide()
         {
             int3x4 a0 = int3x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903);
@@ -272,7 +272,7 @@ public static void int3x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_greater_wide_scalar()
         {
             int3x4 a0 = int3x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960);
@@ -296,7 +296,7 @@ public static void int3x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -320,7 +320,7 @@ public static void int3x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_less_equal_wide_wide()
         {
             int3x4 a0 = int3x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946);
@@ -344,7 +344,7 @@ public static void int3x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_less_equal_wide_scalar()
         {
             int3x4 a0 = int3x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501);
@@ -368,7 +368,7 @@ public static void int3x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -392,7 +392,7 @@ public static void int3x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_greater_equal_wide_wide()
         {
             int3x4 a0 = int3x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752);
@@ -416,7 +416,7 @@ public static void int3x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_greater_equal_wide_scalar()
         {
             int3x4 a0 = int3x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390);
@@ -440,7 +440,7 @@ public static void int3x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -464,7 +464,7 @@ public static void int3x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_add_wide_wide()
         {
             int3x4 a0 = int3x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462);
@@ -488,7 +488,7 @@ public static void int3x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_add_wide_scalar()
         {
             int3x4 a0 = int3x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642);
@@ -512,7 +512,7 @@ public static void int3x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -536,7 +536,7 @@ public static void int3x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_sub_wide_wide()
         {
             int3x4 a0 = int3x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285);
@@ -560,7 +560,7 @@ public static void int3x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_sub_wide_scalar()
         {
             int3x4 a0 = int3x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508);
@@ -584,7 +584,7 @@ public static void int3x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -608,7 +608,7 @@ public static void int3x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_mul_wide_wide()
         {
             int3x4 a0 = int3x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842);
@@ -632,7 +632,7 @@ public static void int3x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_mul_wide_scalar()
         {
             int3x4 a0 = int3x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203);
@@ -656,7 +656,7 @@ public static void int3x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -680,7 +680,7 @@ public static void int3x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_div_wide_wide()
         {
             int3x4 a0 = int3x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736);
@@ -704,7 +704,7 @@ public static void int3x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_div_wide_scalar()
         {
             int3x4 a0 = int3x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377);
@@ -728,7 +728,7 @@ public static void int3x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -752,7 +752,7 @@ public static void int3x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_mod_wide_wide()
         {
             int3x4 a0 = int3x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293);
@@ -776,7 +776,7 @@ public static void int3x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_mod_wide_scalar()
         {
             int3x4 a0 = int3x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785);
@@ -800,7 +800,7 @@ public static void int3x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -824,7 +824,7 @@ public static void int3x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_plus()
         {
             int3x4 a0 = int3x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223);
@@ -844,7 +844,7 @@ public static void int3x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_neg()
         {
             int3x4 a0 = int3x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822);
@@ -864,7 +864,7 @@ public static void int3x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_prefix_inc()
         {
             int3x4 a0 = int3x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735);
@@ -884,7 +884,7 @@ public static void int3x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_postfix_inc()
         {
             int3x4 a0 = int3x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446);
@@ -904,7 +904,7 @@ public static void int3x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_prefix_dec()
         {
             int3x4 a0 = int3x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220);
@@ -924,7 +924,7 @@ public static void int3x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_postfix_dec()
         {
             int3x4 a0 = int3x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851);
@@ -944,7 +944,7 @@ public static void int3x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_bitwise_and_wide_wide()
         {
             int3x4 a0 = int3x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302);
@@ -968,7 +968,7 @@ public static void int3x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_bitwise_and_wide_scalar()
         {
             int3x4 a0 = int3x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546);
@@ -992,7 +992,7 @@ public static void int3x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1016,7 +1016,7 @@ public static void int3x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_bitwise_or_wide_wide()
         {
             int3x4 a0 = int3x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227);
@@ -1040,7 +1040,7 @@ public static void int3x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_bitwise_or_wide_scalar()
         {
             int3x4 a0 = int3x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676);
@@ -1064,7 +1064,7 @@ public static void int3x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1088,7 +1088,7 @@ public static void int3x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_bitwise_xor_wide_wide()
         {
             int3x4 a0 = int3x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919);
@@ -1112,7 +1112,7 @@ public static void int3x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_bitwise_xor_wide_scalar()
         {
             int3x4 a0 = int3x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786);
@@ -1136,7 +1136,7 @@ public static void int3x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1160,7 +1160,7 @@ public static void int3x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_left_shift()
         {
             int3x4 a0 = int3x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902);
@@ -1184,7 +1184,7 @@ public static void int3x4_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_right_shift()
         {
             int3x4 a0 = int3x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878);
@@ -1208,7 +1208,7 @@ public static void int3x4_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3x4_operator_bitwise_not()
         {
             int3x4 a0 = int3x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785);
diff --git a/src/Tests/Tests/Shared/TestInt4.gen.cs b/src/Tests/Tests/Shared/TestInt4.gen.cs
index 5aaff365..3c712b61 100644
--- a/src/Tests/Tests/Shared/TestInt4.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_zero()
         {
             TestUtils.AreEqual(0, int4.zero.x);
@@ -24,7 +24,7 @@ public static void int4_zero()
             TestUtils.AreEqual(0, int4.zero.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_constructor()
         {
             int4 a = new int4(1, 2, 3, 4);
@@ -34,7 +34,7 @@ public static void int4_constructor()
             TestUtils.AreEqual(4, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_scalar_constructor()
         {
             int4 a = new int4(17);
@@ -44,7 +44,7 @@ public static void int4_scalar_constructor()
             TestUtils.AreEqual(17, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_static_constructor()
         {
             int4 a = int4(1, 2, 3, 4);
@@ -54,7 +54,7 @@ public static void int4_static_constructor()
             TestUtils.AreEqual(4, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_static_scalar_constructor()
         {
             int4 a = int4(17);
@@ -64,7 +64,7 @@ public static void int4_static_scalar_constructor()
             TestUtils.AreEqual(17, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_equal_wide_wide()
         {
             int4 a0 = int4(2105871082, 35218899, 1550755093, 764676020);
@@ -88,7 +88,7 @@ public static void int4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_equal_wide_scalar()
         {
             int4 a0 = int4(437822262, 2020661134, 541786900, 853113810);
@@ -112,7 +112,7 @@ public static void int4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -136,7 +136,7 @@ public static void int4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_not_equal_wide_wide()
         {
             int4 a0 = int4(1977284100, 1293292704, 1547283851, 422428953);
@@ -160,7 +160,7 @@ public static void int4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_not_equal_wide_scalar()
         {
             int4 a0 = int4(1038269360, 1427812625, 103361237, 1347017023);
@@ -184,7 +184,7 @@ public static void int4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -208,7 +208,7 @@ public static void int4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_less_wide_wide()
         {
             int4 a0 = int4(1486550609, 1779244308, 1602148045, 1614085440);
@@ -232,7 +232,7 @@ public static void int4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_less_wide_scalar()
         {
             int4 a0 = int4(796797557, 670113454, 933579492, 278884514);
@@ -256,7 +256,7 @@ public static void int4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -280,7 +280,7 @@ public static void int4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_greater_wide_wide()
         {
             int4 a0 = int4(2087717754, 1725569452, 1298066182, 1693943616);
@@ -304,7 +304,7 @@ public static void int4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_greater_wide_scalar()
         {
             int4 a0 = int4(1208626274, 239697208, 1979453345, 1253474001);
@@ -328,7 +328,7 @@ public static void int4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -352,7 +352,7 @@ public static void int4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_less_equal_wide_wide()
         {
             int4 a0 = int4(154092149, 1515170149, 1083970332, 785807178);
@@ -376,7 +376,7 @@ public static void int4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_less_equal_wide_scalar()
         {
             int4 a0 = int4(1479531977, 1427983411, 415250630, 1245345407);
@@ -400,7 +400,7 @@ public static void int4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -424,7 +424,7 @@ public static void int4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_greater_equal_wide_wide()
         {
             int4 a0 = int4(8538378, 2131749726, 265427108, 523609761);
@@ -448,7 +448,7 @@ public static void int4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_greater_equal_wide_scalar()
         {
             int4 a0 = int4(2049236663, 182691143, 634973382, 1197012109);
@@ -472,7 +472,7 @@ public static void int4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -496,7 +496,7 @@ public static void int4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_add_wide_wide()
         {
             int4 a0 = int4(2135171378, 21433296, 1954723494, 683604307);
@@ -520,7 +520,7 @@ public static void int4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_add_wide_scalar()
         {
             int4 a0 = int4(665815972, 1783729250, 1591678394, 1284528538);
@@ -544,7 +544,7 @@ public static void int4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -568,7 +568,7 @@ public static void int4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_sub_wide_wide()
         {
             int4 a0 = int4(1410318491, 1097280168, 1827039044, 28881338);
@@ -592,7 +592,7 @@ public static void int4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_sub_wide_scalar()
         {
             int4 a0 = int4(1508669340, 1594795463, 266707545, 643102647);
@@ -616,7 +616,7 @@ public static void int4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -640,7 +640,7 @@ public static void int4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_mul_wide_wide()
         {
             int4 a0 = int4(61417577, 219585476, 1362520891, 1511084277);
@@ -664,7 +664,7 @@ public static void int4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_mul_wide_scalar()
         {
             int4 a0 = int4(871746615, 492532311, 570557670, 2142306629);
@@ -688,7 +688,7 @@ public static void int4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -712,7 +712,7 @@ public static void int4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_div_wide_wide()
         {
             int4 a0 = int4(333171510, 858154903, 1181365836, 671357749);
@@ -736,7 +736,7 @@ public static void int4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_div_wide_scalar()
         {
             int4 a0 = int4(1433072926, 1073958635, 1195142312, 536596719);
@@ -760,7 +760,7 @@ public static void int4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -784,7 +784,7 @@ public static void int4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_mod_wide_wide()
         {
             int4 a0 = int4(258342924, 1454754891, 723352342, 1981431473);
@@ -808,7 +808,7 @@ public static void int4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_mod_wide_scalar()
         {
             int4 a0 = int4(560988938, 629524514, 767711194, 434281967);
@@ -832,7 +832,7 @@ public static void int4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -856,7 +856,7 @@ public static void int4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_plus()
         {
             int4 a0 = int4(195392567, 222719748, 1002351013, 1570765263);
@@ -876,7 +876,7 @@ public static void int4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_neg()
         {
             int4 a0 = int4(1385088677, 94114564, 1350664872, 1458616659);
@@ -896,7 +896,7 @@ public static void int4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_prefix_inc()
         {
             int4 a0 = int4(780471723, 954741756, 272723451, 2142862245);
@@ -916,7 +916,7 @@ public static void int4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_postfix_inc()
         {
             int4 a0 = int4(241865086, 2145821641, 1596166022, 803592338);
@@ -936,7 +936,7 @@ public static void int4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_prefix_dec()
         {
             int4 a0 = int4(1331961415, 1612382200, 1401591249, 2042075388);
@@ -956,7 +956,7 @@ public static void int4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_postfix_dec()
         {
             int4 a0 = int4(1870005937, 1708534798, 704493460, 462940703);
@@ -976,7 +976,7 @@ public static void int4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_bitwise_and_wide_wide()
         {
             int4 a0 = int4(1055241304, 859321394, 1088358961, 2090949513);
@@ -1000,7 +1000,7 @@ public static void int4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_bitwise_and_wide_scalar()
         {
             int4 a0 = int4(1513158868, 284695609, 734595037, 1566510707);
@@ -1024,7 +1024,7 @@ public static void int4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1048,7 +1048,7 @@ public static void int4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_bitwise_or_wide_wide()
         {
             int4 a0 = int4(1920951869, 1750772852, 1420019191, 732977093);
@@ -1072,7 +1072,7 @@ public static void int4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_bitwise_or_wide_scalar()
         {
             int4 a0 = int4(1295304853, 1307252624, 350194630, 1128063578);
@@ -1096,7 +1096,7 @@ public static void int4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1120,7 +1120,7 @@ public static void int4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_bitwise_xor_wide_wide()
         {
             int4 a0 = int4(1843655608, 362425681, 640805534, 1342040268);
@@ -1144,7 +1144,7 @@ public static void int4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_bitwise_xor_wide_scalar()
         {
             int4 a0 = int4(169345668, 176087064, 2084362901, 1663924004);
@@ -1168,7 +1168,7 @@ public static void int4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1192,7 +1192,7 @@ public static void int4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_left_shift()
         {
             int4 a0 = int4(1129100049, 829482269, 1571297368, 443753193);
@@ -1216,7 +1216,7 @@ public static void int4_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_right_shift()
         {
             int4 a0 = int4(809126085, 908563670, 763568837, 1986717290);
@@ -1240,7 +1240,7 @@ public static void int4_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_operator_bitwise_not()
         {
             int4 a0 = int4(111796841, 603562399, 745091931, 853183268);
@@ -1260,7 +1260,7 @@ public static void int4_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_shuffle_result_1()
         {
             int4 a = int4(0, 1, 2, 3);
@@ -1276,7 +1276,7 @@ public static void int4_shuffle_result_1()
             TestUtils.AreEqual((7), shuffle(a, b, ShuffleComponent.RightW));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_shuffle_result_2()
         {
             int4 a = int4(0, 1, 2, 3);
@@ -1300,7 +1300,7 @@ public static void int4_shuffle_result_2()
             TestUtils.AreEqual(int2(1, 3), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_shuffle_result_3()
         {
             int4 a = int4(0, 1, 2, 3);
@@ -1324,7 +1324,7 @@ public static void int4_shuffle_result_3()
             TestUtils.AreEqual(int3(5, 1, 7), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_shuffle_result_4()
         {
             int4 a = int4(0, 1, 2, 3);
diff --git a/src/Tests/Tests/Shared/TestInt4x2.gen.cs b/src/Tests/Tests/Shared/TestInt4x2.gen.cs
index c4528cd7..8eaa8828 100644
--- a/src/Tests/Tests/Shared/TestInt4x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt4x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt4x2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_zero()
         {
             TestUtils.AreEqual(0, int4x2.zero.c0.x);
@@ -28,7 +28,7 @@ public static void int4x2_zero()
             TestUtils.AreEqual(0, int4x2.zero.c1.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_equal_wide_wide()
         {
             int4x2 a0 = int4x2(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316);
@@ -52,7 +52,7 @@ public static void int4x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_equal_wide_scalar()
         {
             int4x2 a0 = int4x2(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849);
@@ -76,7 +76,7 @@ public static void int4x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -100,7 +100,7 @@ public static void int4x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_not_equal_wide_wide()
         {
             int4x2 a0 = int4x2(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074);
@@ -124,7 +124,7 @@ public static void int4x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_not_equal_wide_scalar()
         {
             int4x2 a0 = int4x2(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717);
@@ -148,7 +148,7 @@ public static void int4x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -172,7 +172,7 @@ public static void int4x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_less_wide_wide()
         {
             int4x2 a0 = int4x2(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431);
@@ -196,7 +196,7 @@ public static void int4x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_less_wide_scalar()
         {
             int4x2 a0 = int4x2(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600);
@@ -220,7 +220,7 @@ public static void int4x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -244,7 +244,7 @@ public static void int4x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_greater_wide_wide()
         {
             int4x2 a0 = int4x2(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508);
@@ -268,7 +268,7 @@ public static void int4x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_greater_wide_scalar()
         {
             int4x2 a0 = int4x2(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098);
@@ -292,7 +292,7 @@ public static void int4x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -316,7 +316,7 @@ public static void int4x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_less_equal_wide_wide()
         {
             int4x2 a0 = int4x2(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725);
@@ -340,7 +340,7 @@ public static void int4x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_less_equal_wide_scalar()
         {
             int4x2 a0 = int4x2(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307);
@@ -364,7 +364,7 @@ public static void int4x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -388,7 +388,7 @@ public static void int4x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_greater_equal_wide_wide()
         {
             int4x2 a0 = int4x2(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970);
@@ -412,7 +412,7 @@ public static void int4x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_greater_equal_wide_scalar()
         {
             int4x2 a0 = int4x2(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187);
@@ -436,7 +436,7 @@ public static void int4x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -460,7 +460,7 @@ public static void int4x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_add_wide_wide()
         {
             int4x2 a0 = int4x2(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062);
@@ -484,7 +484,7 @@ public static void int4x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_add_wide_scalar()
         {
             int4x2 a0 = int4x2(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017);
@@ -508,7 +508,7 @@ public static void int4x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -532,7 +532,7 @@ public static void int4x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_sub_wide_wide()
         {
             int4x2 a0 = int4x2(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215);
@@ -556,7 +556,7 @@ public static void int4x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_sub_wide_scalar()
         {
             int4x2 a0 = int4x2(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511);
@@ -580,7 +580,7 @@ public static void int4x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -604,7 +604,7 @@ public static void int4x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_mul_wide_wide()
         {
             int4x2 a0 = int4x2(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644);
@@ -628,7 +628,7 @@ public static void int4x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_mul_wide_scalar()
         {
             int4x2 a0 = int4x2(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514);
@@ -652,7 +652,7 @@ public static void int4x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -676,7 +676,7 @@ public static void int4x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_div_wide_wide()
         {
             int4x2 a0 = int4x2(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814);
@@ -700,7 +700,7 @@ public static void int4x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_div_wide_scalar()
         {
             int4x2 a0 = int4x2(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670);
@@ -724,7 +724,7 @@ public static void int4x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -748,7 +748,7 @@ public static void int4x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_mod_wide_wide()
         {
             int4x2 a0 = int4x2(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004);
@@ -772,7 +772,7 @@ public static void int4x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_mod_wide_scalar()
         {
             int4x2 a0 = int4x2(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916);
@@ -796,7 +796,7 @@ public static void int4x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -820,7 +820,7 @@ public static void int4x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_plus()
         {
             int4x2 a0 = int4x2(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785);
@@ -840,7 +840,7 @@ public static void int4x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_neg()
         {
             int4x2 a0 = int4x2(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961);
@@ -860,7 +860,7 @@ public static void int4x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_prefix_inc()
         {
             int4x2 a0 = int4x2(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162);
@@ -880,7 +880,7 @@ public static void int4x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_postfix_inc()
         {
             int4x2 a0 = int4x2(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244);
@@ -900,7 +900,7 @@ public static void int4x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_prefix_dec()
         {
             int4x2 a0 = int4x2(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664);
@@ -920,7 +920,7 @@ public static void int4x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_postfix_dec()
         {
             int4x2 a0 = int4x2(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351);
@@ -940,7 +940,7 @@ public static void int4x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_bitwise_and_wide_wide()
         {
             int4x2 a0 = int4x2(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753);
@@ -964,7 +964,7 @@ public static void int4x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_bitwise_and_wide_scalar()
         {
             int4x2 a0 = int4x2(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908);
@@ -988,7 +988,7 @@ public static void int4x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1012,7 +1012,7 @@ public static void int4x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_bitwise_or_wide_wide()
         {
             int4x2 a0 = int4x2(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323);
@@ -1036,7 +1036,7 @@ public static void int4x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_bitwise_or_wide_scalar()
         {
             int4x2 a0 = int4x2(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350);
@@ -1060,7 +1060,7 @@ public static void int4x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1084,7 +1084,7 @@ public static void int4x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_bitwise_xor_wide_wide()
         {
             int4x2 a0 = int4x2(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658);
@@ -1108,7 +1108,7 @@ public static void int4x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_bitwise_xor_wide_scalar()
         {
             int4x2 a0 = int4x2(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783);
@@ -1132,7 +1132,7 @@ public static void int4x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1156,7 +1156,7 @@ public static void int4x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_left_shift()
         {
             int4x2 a0 = int4x2(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862);
@@ -1180,7 +1180,7 @@ public static void int4x2_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_right_shift()
         {
             int4x2 a0 = int4x2(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632);
@@ -1204,7 +1204,7 @@ public static void int4x2_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x2_operator_bitwise_not()
         {
             int4x2 a0 = int4x2(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135);
diff --git a/src/Tests/Tests/Shared/TestInt4x3.gen.cs b/src/Tests/Tests/Shared/TestInt4x3.gen.cs
index fec49565..c8662413 100644
--- a/src/Tests/Tests/Shared/TestInt4x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt4x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt4x3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_zero()
         {
             TestUtils.AreEqual(0, int4x3.zero.c0.x);
@@ -32,7 +32,7 @@ public static void int4x3_zero()
             TestUtils.AreEqual(0, int4x3.zero.c2.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_equal_wide_wide()
         {
             int4x3 a0 = int4x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837);
@@ -56,7 +56,7 @@ public static void int4x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_equal_wide_scalar()
         {
             int4x3 a0 = int4x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137);
@@ -80,7 +80,7 @@ public static void int4x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -104,7 +104,7 @@ public static void int4x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_not_equal_wide_wide()
         {
             int4x3 a0 = int4x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545);
@@ -128,7 +128,7 @@ public static void int4x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_not_equal_wide_scalar()
         {
             int4x3 a0 = int4x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494);
@@ -152,7 +152,7 @@ public static void int4x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -176,7 +176,7 @@ public static void int4x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_less_wide_wide()
         {
             int4x3 a0 = int4x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069);
@@ -200,7 +200,7 @@ public static void int4x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_less_wide_scalar()
         {
             int4x3 a0 = int4x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417);
@@ -224,7 +224,7 @@ public static void int4x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -248,7 +248,7 @@ public static void int4x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_greater_wide_wide()
         {
             int4x3 a0 = int4x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903);
@@ -272,7 +272,7 @@ public static void int4x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_greater_wide_scalar()
         {
             int4x3 a0 = int4x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960);
@@ -296,7 +296,7 @@ public static void int4x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -320,7 +320,7 @@ public static void int4x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_less_equal_wide_wide()
         {
             int4x3 a0 = int4x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946);
@@ -344,7 +344,7 @@ public static void int4x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_less_equal_wide_scalar()
         {
             int4x3 a0 = int4x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501);
@@ -368,7 +368,7 @@ public static void int4x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -392,7 +392,7 @@ public static void int4x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_greater_equal_wide_wide()
         {
             int4x3 a0 = int4x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752);
@@ -416,7 +416,7 @@ public static void int4x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_greater_equal_wide_scalar()
         {
             int4x3 a0 = int4x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390);
@@ -440,7 +440,7 @@ public static void int4x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -464,7 +464,7 @@ public static void int4x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_add_wide_wide()
         {
             int4x3 a0 = int4x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462);
@@ -488,7 +488,7 @@ public static void int4x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_add_wide_scalar()
         {
             int4x3 a0 = int4x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642);
@@ -512,7 +512,7 @@ public static void int4x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -536,7 +536,7 @@ public static void int4x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_sub_wide_wide()
         {
             int4x3 a0 = int4x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285);
@@ -560,7 +560,7 @@ public static void int4x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_sub_wide_scalar()
         {
             int4x3 a0 = int4x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508);
@@ -584,7 +584,7 @@ public static void int4x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -608,7 +608,7 @@ public static void int4x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_mul_wide_wide()
         {
             int4x3 a0 = int4x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842);
@@ -632,7 +632,7 @@ public static void int4x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_mul_wide_scalar()
         {
             int4x3 a0 = int4x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203);
@@ -656,7 +656,7 @@ public static void int4x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -680,7 +680,7 @@ public static void int4x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_div_wide_wide()
         {
             int4x3 a0 = int4x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736);
@@ -704,7 +704,7 @@ public static void int4x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_div_wide_scalar()
         {
             int4x3 a0 = int4x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377);
@@ -728,7 +728,7 @@ public static void int4x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -752,7 +752,7 @@ public static void int4x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_mod_wide_wide()
         {
             int4x3 a0 = int4x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293);
@@ -776,7 +776,7 @@ public static void int4x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_mod_wide_scalar()
         {
             int4x3 a0 = int4x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785);
@@ -800,7 +800,7 @@ public static void int4x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -824,7 +824,7 @@ public static void int4x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_plus()
         {
             int4x3 a0 = int4x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223);
@@ -844,7 +844,7 @@ public static void int4x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_neg()
         {
             int4x3 a0 = int4x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822);
@@ -864,7 +864,7 @@ public static void int4x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_prefix_inc()
         {
             int4x3 a0 = int4x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735);
@@ -884,7 +884,7 @@ public static void int4x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_postfix_inc()
         {
             int4x3 a0 = int4x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446);
@@ -904,7 +904,7 @@ public static void int4x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_prefix_dec()
         {
             int4x3 a0 = int4x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220);
@@ -924,7 +924,7 @@ public static void int4x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_postfix_dec()
         {
             int4x3 a0 = int4x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851);
@@ -944,7 +944,7 @@ public static void int4x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_bitwise_and_wide_wide()
         {
             int4x3 a0 = int4x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302);
@@ -968,7 +968,7 @@ public static void int4x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_bitwise_and_wide_scalar()
         {
             int4x3 a0 = int4x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546);
@@ -992,7 +992,7 @@ public static void int4x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1016,7 +1016,7 @@ public static void int4x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_bitwise_or_wide_wide()
         {
             int4x3 a0 = int4x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227);
@@ -1040,7 +1040,7 @@ public static void int4x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_bitwise_or_wide_scalar()
         {
             int4x3 a0 = int4x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676);
@@ -1064,7 +1064,7 @@ public static void int4x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1088,7 +1088,7 @@ public static void int4x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_bitwise_xor_wide_wide()
         {
             int4x3 a0 = int4x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919);
@@ -1112,7 +1112,7 @@ public static void int4x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_bitwise_xor_wide_scalar()
         {
             int4x3 a0 = int4x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786);
@@ -1136,7 +1136,7 @@ public static void int4x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1160,7 +1160,7 @@ public static void int4x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_left_shift()
         {
             int4x3 a0 = int4x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902);
@@ -1184,7 +1184,7 @@ public static void int4x3_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_right_shift()
         {
             int4x3 a0 = int4x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878);
@@ -1208,7 +1208,7 @@ public static void int4x3_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x3_operator_bitwise_not()
         {
             int4x3 a0 = int4x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785);
diff --git a/src/Tests/Tests/Shared/TestInt4x4.gen.cs b/src/Tests/Tests/Shared/TestInt4x4.gen.cs
index 81786fb7..408529a2 100644
--- a/src/Tests/Tests/Shared/TestInt4x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestInt4x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestInt4x4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_zero()
         {
             TestUtils.AreEqual(0, int4x4.zero.c0.x);
@@ -36,7 +36,7 @@ public static void int4x4_zero()
             TestUtils.AreEqual(0, int4x4.zero.c3.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_identity()
         {
             TestUtils.AreEqual(1, int4x4.identity.c0.x);
@@ -57,7 +57,7 @@ public static void int4x4_identity()
             TestUtils.AreEqual(1, int4x4.identity.c3.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_equal_wide_wide()
         {
             int4x4 a0 = int4x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837, 1303661760, 2044073738, 370395888, 1822916805);
@@ -81,7 +81,7 @@ public static void int4x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_equal_wide_scalar()
         {
             int4x4 a0 = int4x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137, 712957637, 2028784869, 1049962241, 1836975611);
@@ -105,7 +105,7 @@ public static void int4x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_equal_scalar_wide()
         {
             int a0 = (542329200);
@@ -129,7 +129,7 @@ public static void int4x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_not_equal_wide_wide()
         {
             int4x4 a0 = int4x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545, 1211445174, 1289303469, 1436402489, 1129570126);
@@ -153,7 +153,7 @@ public static void int4x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_not_equal_wide_scalar()
         {
             int4x4 a0 = int4x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494, 507918242, 1702162286, 923269270, 166187260);
@@ -177,7 +177,7 @@ public static void int4x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_not_equal_scalar_wide()
         {
             int a0 = (1652127596);
@@ -201,7 +201,7 @@ public static void int4x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_less_wide_wide()
         {
             int4x4 a0 = int4x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069, 840685445, 1220554047, 2013681746, 192965012);
@@ -225,7 +225,7 @@ public static void int4x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_less_wide_scalar()
         {
             int4x4 a0 = int4x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417, 1857132231, 1909506562, 1294006045, 952084157);
@@ -249,7 +249,7 @@ public static void int4x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_less_scalar_wide()
         {
             int a0 = (186400299);
@@ -273,7 +273,7 @@ public static void int4x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_greater_wide_wide()
         {
             int4x4 a0 = int4x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903, 2029731638, 1377214212, 1207816926, 474621063);
@@ -297,7 +297,7 @@ public static void int4x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_greater_wide_scalar()
         {
             int4x4 a0 = int4x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960, 1850273578, 206147145, 325913453, 333381537);
@@ -321,7 +321,7 @@ public static void int4x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_greater_scalar_wide()
         {
             int a0 = (480938827);
@@ -345,7 +345,7 @@ public static void int4x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_less_equal_wide_wide()
         {
             int4x4 a0 = int4x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946, 1387761992, 195272789, 659549000, 888761458);
@@ -369,7 +369,7 @@ public static void int4x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_less_equal_wide_scalar()
         {
             int4x4 a0 = int4x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501, 518127023, 1246249980, 1097326500, 1964410699);
@@ -393,7 +393,7 @@ public static void int4x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_less_equal_scalar_wide()
         {
             int a0 = (1899193992);
@@ -417,7 +417,7 @@ public static void int4x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_greater_equal_wide_wide()
         {
             int4x4 a0 = int4x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752, 424526026, 788481984, 1662488497, 870326690);
@@ -441,7 +441,7 @@ public static void int4x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_greater_equal_wide_scalar()
         {
             int4x4 a0 = int4x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390, 996159180, 2111455181, 727766399, 96217144);
@@ -465,7 +465,7 @@ public static void int4x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_greater_equal_scalar_wide()
         {
             int a0 = (1859811087);
@@ -489,7 +489,7 @@ public static void int4x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_add_wide_wide()
         {
             int4x4 a0 = int4x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462, 1218855698, 700538222, 1702057277, 1788251699);
@@ -513,7 +513,7 @@ public static void int4x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_add_wide_scalar()
         {
             int4x4 a0 = int4x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642, 678921480, 625943813, 512157429, 1470648741);
@@ -537,7 +537,7 @@ public static void int4x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_add_scalar_wide()
         {
             int a0 = (359966320);
@@ -561,7 +561,7 @@ public static void int4x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_sub_wide_wide()
         {
             int4x4 a0 = int4x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285, 1125909359, 1842588095, 848561896, 614448464);
@@ -585,7 +585,7 @@ public static void int4x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_sub_wide_scalar()
         {
             int4x4 a0 = int4x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508, 1806482044, 1994553647, 2101812429, 1482736902);
@@ -609,7 +609,7 @@ public static void int4x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_sub_scalar_wide()
         {
             int a0 = (893369501);
@@ -633,7 +633,7 @@ public static void int4x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_mul_wide_wide()
         {
             int4x4 a0 = int4x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842, 522856538, 278370196, 289217012, 2083410174);
@@ -657,7 +657,7 @@ public static void int4x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_mul_wide_scalar()
         {
             int4x4 a0 = int4x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203, 638897141, 268562104, 1007838321, 1163240135);
@@ -681,7 +681,7 @@ public static void int4x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_mul_scalar_wide()
         {
             int a0 = (1152242766);
@@ -705,7 +705,7 @@ public static void int4x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_div_wide_wide()
         {
             int4x4 a0 = int4x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736, 200852358, 129983172, 500176108, 472051781);
@@ -729,7 +729,7 @@ public static void int4x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_div_wide_scalar()
         {
             int4x4 a0 = int4x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377, 643754735, 2084019932, 2047825037, 458304263);
@@ -753,7 +753,7 @@ public static void int4x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_div_scalar_wide()
         {
             int a0 = (519165704);
@@ -777,7 +777,7 @@ public static void int4x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_mod_wide_wide()
         {
             int4x4 a0 = int4x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293, 813624265, 1617478722, 498370451, 780075943);
@@ -801,7 +801,7 @@ public static void int4x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_mod_wide_scalar()
         {
             int4x4 a0 = int4x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785, 327476870, 1617696916, 379853074, 477430114);
@@ -825,7 +825,7 @@ public static void int4x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_mod_scalar_wide()
         {
             int a0 = (933347930);
@@ -849,7 +849,7 @@ public static void int4x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_plus()
         {
             int4x4 a0 = int4x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223, 715660442, 1995564647, 69731564, 1317851903);
@@ -869,7 +869,7 @@ public static void int4x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_neg()
         {
             int4x4 a0 = int4x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822, 2051940607, 1434247484, 485368391, 908365416);
@@ -889,7 +889,7 @@ public static void int4x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_prefix_inc()
         {
             int4x4 a0 = int4x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735, 1584496757, 1170613526, 986715680, 1701179230);
@@ -909,7 +909,7 @@ public static void int4x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_postfix_inc()
         {
             int4x4 a0 = int4x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446, 1343289659, 1227160199, 947635082, 137930180);
@@ -929,7 +929,7 @@ public static void int4x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_prefix_dec()
         {
             int4x4 a0 = int4x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220, 312317355, 1027543764, 1595492535, 1426262619);
@@ -949,7 +949,7 @@ public static void int4x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_postfix_dec()
         {
             int4x4 a0 = int4x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851, 653673271, 140452688, 1928164223, 1760916301);
@@ -969,7 +969,7 @@ public static void int4x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_bitwise_and_wide_wide()
         {
             int4x4 a0 = int4x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302, 1929998247, 1504941434, 470682792, 713577376);
@@ -993,7 +993,7 @@ public static void int4x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_bitwise_and_wide_scalar()
         {
             int4x4 a0 = int4x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546, 1873208293, 126982769, 651482651, 1383096952);
@@ -1017,7 +1017,7 @@ public static void int4x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_bitwise_and_scalar_wide()
         {
             int a0 = (477163326);
@@ -1041,7 +1041,7 @@ public static void int4x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_bitwise_or_wide_wide()
         {
             int4x4 a0 = int4x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227, 1686257697, 2137727522, 1569900650, 856504729);
@@ -1065,7 +1065,7 @@ public static void int4x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_bitwise_or_wide_scalar()
         {
             int4x4 a0 = int4x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676, 228656898, 41280811, 1536908787, 606786773);
@@ -1089,7 +1089,7 @@ public static void int4x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_bitwise_or_scalar_wide()
         {
             int a0 = (1768627592);
@@ -1113,7 +1113,7 @@ public static void int4x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_bitwise_xor_wide_wide()
         {
             int4x4 a0 = int4x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919, 26631152, 1016475570, 1862440929, 379588576);
@@ -1137,7 +1137,7 @@ public static void int4x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_bitwise_xor_wide_scalar()
         {
             int4x4 a0 = int4x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786, 625604047, 1700827127, 2003392824, 1481813598);
@@ -1161,7 +1161,7 @@ public static void int4x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_bitwise_xor_scalar_wide()
         {
             int a0 = (1361775641);
@@ -1185,7 +1185,7 @@ public static void int4x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_left_shift()
         {
             int4x4 a0 = int4x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902, 1959056531, 1779118882, 1451674188, 2082026915);
@@ -1209,7 +1209,7 @@ public static void int4x4_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_right_shift()
         {
             int4x4 a0 = int4x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878, 667378673, 1611921244, 307750782, 479442287);
@@ -1233,7 +1233,7 @@ public static void int4x4_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4x4_operator_bitwise_not()
         {
             int4x4 a0 = int4x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785, 916013379, 203444882, 1172294211, 1020232736);
diff --git a/src/Tests/Tests/Shared/TestMath.cs b/src/Tests/Tests/Shared/TestMath.cs
index 4ba1c895..d22d82a7 100644
--- a/src/Tests/Tests/Shared/TestMath.cs
+++ b/src/Tests/Tests/Shared/TestMath.cs
@@ -8,7 +8,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public partial class TestMath
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asint_uint()
         {
             TestUtils.AreEqual(0, asint(0u));
@@ -19,7 +19,7 @@ public static void asint_uint()
             TestUtils.AreEqual(-1, asint(0xFFFFFFFFu));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asint_uint2()
         {
             TestUtils.AreEqual(int2(0, 0x12345678), asint(uint2(0u, 0x12345678u)));
@@ -27,21 +27,21 @@ public static void asint_uint2()
             TestUtils.AreEqual(int2(-2023406815, -1), asint(uint2(0x87654321u, 0xFFFFFFFFu)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asint_uint3()
         {
             TestUtils.AreEqual(int3(0, 0x12345678, 0x7FFFFFFF), asint(uint3(0u, 0x12345678u, 0x7FFFFFFFu)));
             TestUtils.AreEqual(int3(-2147483648, -2023406815, -1), asint(uint3(0x80000000u, 0x87654321u, 0xFFFFFFFFu)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asint_uint4()
         {
             TestUtils.AreEqual(int4(0, 0x12345678, 0x7FFFFFFF, -2147483648), asint(uint4(0u, 0x12345678u, 0x7FFFFFFFu, 0x80000000u)));
             TestUtils.AreEqual(int4(-2023406815, -1, 0, 0), asint(uint4(0x87654321u, 0xFFFFFFFFu, 0u, 0u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asint_float()
         {
             TestUtils.AreEqual(0, asint(0.0f));
@@ -56,14 +56,14 @@ public static void asint_float()
             TestUtils.AreEqual(unchecked((int)0xFF800000), asint(float.NegativeInfinity));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asint_float_signed_zero()
         {
             TestUtils.AreEqual(unchecked((int)0x80000000), asint(TestUtils.SignedFloatZero()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asint_float2()
         {
             TestUtils.AreEqual(int2(0, 0x3F800000), asint(float2(0.0f, 1.0f)));
@@ -75,14 +75,14 @@ public static void asint_float2()
             TestUtils.AreEqual(int2(0, 0), asint(float2(0.0f, 0.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asint_float2_signed_zero()
         {
             TestUtils.AreEqual(int2(unchecked((int)0x80000000), unchecked((int)0x80000000)), asint(float2(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asint_float3()
         {
             TestUtils.AreEqual(int3(0, 0x3F800000, 0x449A51EC), asint(float3(0.0f, 1.0f, 1234.56f)));
@@ -91,14 +91,14 @@ public static void asint_float3()
             TestUtils.AreEqual(int3(unchecked((int)0xC49A51EC), unchecked((int)0xFF800000), 0), asint(float3(-1234.56f, float.NegativeInfinity, 0.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asint_float3_signed_zero()
         {
             TestUtils.AreEqual(int3(unchecked((int)0x80000000), unchecked((int)0x80000000), unchecked((int)0x80000000)), asint(float3(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asint_float4()
         {
             TestUtils.AreEqual(int4(0, 0x3F800000, 0x449A51EC, 0x7F800000), asint(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity)));
@@ -106,14 +106,14 @@ public static void asint_float4()
             TestUtils.AreEqual(int4(unchecked((int)0x7FC00000), unchecked((int)0xBF800000), unchecked((int)0xC49A51EC), unchecked((int)0xFF800000)), asint(float4(TestUtils.UnsignedFloatQNaN(), -1.0f, -1234.56f, float.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asint_float4_signed_zero()
         {
             TestUtils.AreEqual(int4(unchecked((int)0x80000000), unchecked((int)0x80000000), unchecked((int)0x80000000), unchecked((int)0x80000000)), asint(float4(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asuint_int()
         {
             TestUtils.AreEqual(0u, asuint(0));
@@ -124,7 +124,7 @@ public static void asuint_int()
             TestUtils.AreEqual(0xFFFFFFFFu, asuint(-1));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asuint_int2()
         {
             TestUtils.AreEqual(uint2(0u, 0x12345678u), asuint(int2(0, 0x12345678)));
@@ -132,21 +132,21 @@ public static void asuint_int2()
             TestUtils.AreEqual(uint2(0x87654321u, 0xFFFFFFFFu), asuint(int2(-2023406815, -1)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asuint_int3()
         {
             TestUtils.AreEqual(uint3(0u, 0x12345678u, 0x7FFFFFFFu), asuint(int3(0, 0x12345678, 0x7FFFFFFF)));
             TestUtils.AreEqual(uint3(0x80000000u, 0x87654321u, 0xFFFFFFFFu), asuint(int3(-2147483648, -2023406815, -1)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asuint_int4()
         {
             TestUtils.AreEqual(uint4(0u, 0x12345678u, 0x7FFFFFFFu, 0x80000000u), asuint(int4(0, 0x12345678, 0x7FFFFFFF, -2147483648)));
             TestUtils.AreEqual(uint4(0x87654321u, 0xFFFFFFFFu, 0u, 0u), asuint(int4(-2023406815, -1, 0, 0)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asuint_float()
         {
             TestUtils.AreEqual(0u, asuint(0.0f));
@@ -161,14 +161,14 @@ public static void asuint_float()
             TestUtils.AreEqual(0xFF800000u, asuint(float.NegativeInfinity));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asuint_float_signed_zero()
         {
             TestUtils.AreEqual(0x80000000u, asuint(TestUtils.SignedFloatZero()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asuint_float2()
         {
             TestUtils.AreEqual(uint2(0u, 0x3F800000u), asuint(float2(0.0f, 1.0f)));
@@ -179,14 +179,14 @@ public static void asuint_float2()
             TestUtils.AreEqual(uint2(0xC49A51ECu, 0xFF800000u), asuint(float2(-1234.56f, float.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asuint_float2_signed_zero()
         {
             TestUtils.AreEqual(uint2(0x80000000u, 0x80000000u), asuint(float2(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asuint_float3()
         {
             TestUtils.AreEqual(uint3(0u, 0x3F800000u, 0x449A51ECu), asuint(float3(0.0f, 1.0f, 1234.56f)));
@@ -195,14 +195,14 @@ public static void asuint_float3()
             TestUtils.AreEqual(uint3(0xC49A51ECu, 0xff800000u, 0u), asuint(float3(-1234.56f, float.NegativeInfinity, 0.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asuint_float3_signed_zero()
         {
             TestUtils.AreEqual(uint3(0x80000000u, 0x80000000u, 0x80000000u), asuint(float3(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asuint_float4()
         {
             TestUtils.AreEqual(uint4(0u, 0x3F800000u, 0x449A51ECu, 0x7F800000u), asuint(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity)));
@@ -210,14 +210,14 @@ public static void asuint_float4()
             TestUtils.AreEqual(uint4(0x7FC00000u, 0xBF800000u, 0xC49A51ECu, 0xFF800000u), asuint(float4(TestUtils.UnsignedFloatQNaN(), -1.0f, -1234.56f, float.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asuint_float4_singed_zero()
         {
             TestUtils.AreEqual(uint4(0x80000000u, 0x80000000u, 0x80000000u, 0x80000000u), asuint(float4(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void aslong_ulong()
         {
             TestUtils.AreEqual(0L, aslong(0ul));
@@ -228,7 +228,7 @@ public static void aslong_ulong()
             TestUtils.AreEqual(-1L, aslong(0xFFFFFFFFFFFFFFFFul));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void aslong_double()
         {
             TestUtils.AreEqual(0L, aslong(0.0));
@@ -242,14 +242,14 @@ public static void aslong_double()
             TestUtils.AreEqual(unchecked((long)0xFFF0000000000000UL), aslong(double.NegativeInfinity));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void aslong_double_signed_zero()
         {
             TestUtils.AreEqual(unchecked((long)0x8000000000000000UL), aslong(TestUtils.SignedDoubleZero()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asulong_long()
         {
             TestUtils.AreEqual(0ul, asulong(0L));
@@ -260,7 +260,7 @@ public static void asulong_long()
             TestUtils.AreEqual(0xFFFFFFFFFFFFFFFFul, asulong(-1L));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asulong_double()
         {
             TestUtils.AreEqual(0UL, asulong(0.0));
@@ -274,14 +274,14 @@ public static void asulong_double()
             TestUtils.AreEqual(0xFFF0000000000000UL, asulong(double.NegativeInfinity));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void asulong_double_signed_zero()
         {
             TestUtils.AreEqual(0x8000000000000000UL, asulong(TestUtils.SignedDoubleZero()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asfloat_int()
         {
             TestUtils.AreEqual(0.0f, asfloat(0));
@@ -297,7 +297,7 @@ public static void asfloat_int()
             TestUtils.AreEqual(asuint(TestUtils.UnsignedFloatQNaN()), asuint(asfloat(unchecked((int)0x7FC00000))));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asfloat_int2()
         {
             TestUtils.AreEqual(float2(0.0f, 1.0f), asfloat(int2(0, 0x3F800000)));
@@ -309,7 +309,7 @@ public static void asfloat_int2()
             TestUtils.AreEqual(asuint(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(int2(unchecked((int)0x7FC00000), unchecked((int)0x7FC00000)))));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asfloat_int3()
         {
             TestUtils.AreEqual(float3(0.0f, 1.0f, 1234.56f), asfloat(int3(0, 0x3F800000, 0x449A51EC)));
@@ -320,7 +320,7 @@ public static void asfloat_int3()
             TestUtils.AreEqual(asuint(float3(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(int3(unchecked((int)0x7FC00000), unchecked((int)0x7FC00000), unchecked((int)0x7FC00000)))));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asfloat_int4()
         {
             TestUtils.AreEqual(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity), asfloat(int4(0, 0x3F800000, 0x449A51EC, 0x7F800000)));
@@ -330,7 +330,7 @@ public static void asfloat_int4()
             TestUtils.AreEqual(asuint(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(int4(unchecked((int)0x7FC00000), unchecked((int)0x7FC00000), unchecked((int)0x7FC00000), unchecked((int)0x7FC00000)))));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asfloat_uint()
         {
             TestUtils.AreEqual(0.0f, asfloat(0u));
@@ -346,7 +346,7 @@ public static void asfloat_uint()
             TestUtils.AreEqual(asuint(TestUtils.UnsignedFloatQNaN()), asuint(asfloat(0x7FC00000u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asfloat_uint2()
         {
             TestUtils.AreEqual(float2(0.0f, 1.0f), asfloat(uint2(0u, 0x3F800000u)));
@@ -358,7 +358,7 @@ public static void asfloat_uint2()
             TestUtils.AreEqual(asuint(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(uint2(0x7FC00000u, 0x7FC00000u))));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asfloat_uint3()
         {
             TestUtils.AreEqual(float3(0.0f, 1.0f, 1234.56f), asfloat(uint3(0u, 0x3F800000u, 0x449A51ECu)));
@@ -369,7 +369,7 @@ public static void asfloat_uint3()
             TestUtils.AreEqual(asuint(float3(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(uint3(0x7FC00000u, 0x7FC00000u, 0x7FC00000u))));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asfloat_uint4()
         {
             TestUtils.AreEqual(float4(0.0f, 1.0f, 1234.56f, float.PositiveInfinity), asfloat(uint4(0u, 0x3F800000u, 0x449A51ECu, 0x7F800000u)));
@@ -379,7 +379,7 @@ public static void asfloat_uint4()
             TestUtils.AreEqual(asuint(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())), asuint(asfloat(uint4(0x7FC00000u, 0x7FC00000u, 0x7FC00000u, 0x7FC00000u))));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asdouble_long()
         {
             TestUtils.AreEqual(0.0, asdouble(0L));
@@ -394,7 +394,7 @@ public static void asdouble_long()
             TestUtils.AreEqual(double.NegativeInfinity, asdouble(unchecked((long)0xFFF0000000000000UL)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void asdouble_ulong()
         {
             TestUtils.AreEqual(0.0, asdouble(0UL));
@@ -409,7 +409,7 @@ public static void asdouble_ulong()
             TestUtils.AreEqual(double.NegativeInfinity, asdouble(0xFFF0000000000000UL));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void faceforward_float2()
         {
             TestUtils.AreEqual(float2(-3.5f, 4.5f), faceforward(float2(3.5f, -4.5f), float2(1.0f, -2.0f), float2(3.0f, -4.0f)));
@@ -417,7 +417,7 @@ public static void faceforward_float2()
             TestUtils.AreEqual(float2(-3.5f, 4.5f), faceforward(float2(3.5f, -4.5f), float2(1.0f, -2.0f), float2(0.0f, 0.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void faceforward_float3()
         {
             TestUtils.AreEqual(float3(-3.5f, 4.5f, -5.5f), faceforward(float3(3.5f, -4.5f, 5.5f), float3(1.0f, -2.0f, 3.0f), float3(3.0f, -4.0f, 5.0f)));
@@ -425,7 +425,7 @@ public static void faceforward_float3()
             TestUtils.AreEqual(float3(-3.5f, 4.5f, -5.5f), faceforward(float3(3.5f, -4.5f, 5.5f), float3(1.0f, -2.0f, 3.0f), float3(0.0f, 0.0f, 0.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void faceforward_float4()
         {
             TestUtils.AreEqual(float4(-3.5f, 4.5f, -5.5f, 6.5f), faceforward(float4(3.5f, -4.5f, 5.5f, -6.5f), float4(1.0f, -2.0f, 3.0f, -4.0f), float4(3.0f, -4.0f, 5.0f, -6.0f)));
@@ -433,7 +433,7 @@ public static void faceforward_float4()
             TestUtils.AreEqual(float4(-3.5f, 4.5f, -5.5f, 6.5f), faceforward(float4(3.5f, -4.5f, 5.5f, -6.5f), float4(1.0f, -2.0f, 3.0f, -4.0f), float4(0.0f, 0.0f, 0.0f, 0.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void faceforward_double2()
         {
             TestUtils.AreEqual(double2(-3.5, 4.5), faceforward(double2(3.5, -4.5), double2(1.0, -2.0), double2(3.0, -4.0)));
@@ -441,7 +441,7 @@ public static void faceforward_double2()
             TestUtils.AreEqual(double2(-3.5, 4.5), faceforward(double2(3.5, -4.5), double2(1.0, -2.0), double2(0.0, 0.0)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void faceforward_double3()
         {
             TestUtils.AreEqual(double3(-3.5, 4.5, -5.5), faceforward(double3(3.5, -4.5, 5.5), double3(1.0, -2.0, 3.0), double3(3.0, -4.0, 5.0)));
@@ -449,7 +449,7 @@ public static void faceforward_double3()
             TestUtils.AreEqual(double3(-3.5, 4.5, -5.5), faceforward(double3(3.5, -4.5, 5.5), double3(1.0, -2.0, 3.0), double3(0.0, 0.0, 0.0)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void faceforward_double4()
         {
             TestUtils.AreEqual(double4(-3.5, 4.5, -5.5, 6.5), faceforward(double4(3.5, -4.5, 5.5, -6.5), double4(1.0, -2.0, 3.0, -4.0), double4(3.0, -4.0, 5.0, -6.0)));
@@ -457,7 +457,7 @@ public static void faceforward_double4()
             TestUtils.AreEqual(double4(-3.5, 4.5, -5.5, 6.5), faceforward(double4(3.5, -4.5, 5.5, -6.5), double4(1.0, -2.0, 3.0, -4.0), double4(0.0, 0.0, 0.0, 0.0)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void modf_float()
         {
             float f, i;
@@ -474,7 +474,7 @@ public static void modf_float()
             TestUtils.AreEqual(0.0f, f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void modf_float2()
         {
             float2 f, i;
@@ -487,7 +487,7 @@ public static void modf_float2()
             TestUtils.AreEqual(float2(0.0f, 0.5f), f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void modf_float3()
         {
             float3 f, i;
@@ -496,7 +496,7 @@ public static void modf_float3()
             TestUtils.AreEqual(float3(0.75f, -0.25f, 0.0f), f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void modf_float4()
         {
             float4 f, i;
@@ -505,7 +505,7 @@ public static void modf_float4()
             TestUtils.AreEqual(float4(0.75f, -0.25f, 0.0f, 0.5f), f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void modf_double()
         {
             double f, i;
@@ -522,7 +522,7 @@ public static void modf_double()
             TestUtils.AreEqual(0.0, f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void modf_double2()
         {
             double2 f, i;
@@ -535,7 +535,7 @@ public static void modf_double2()
             TestUtils.AreEqual(double2(0.0, 0.5), f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void modf_double3()
         {
             double3 f, i;
@@ -544,7 +544,7 @@ public static void modf_double3()
             TestUtils.AreEqual(double3(0.75, -0.25, 0.0), f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void modf_double4()
         {
             double4 f, i;
@@ -553,21 +553,21 @@ public static void modf_double4()
             TestUtils.AreEqual(double4(0.75, -0.25, 0.0, 0.5f), f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void normalize_float2()
         {
             TestUtils.AreEqual(float2(0.504883f, -0.863188f), normalize(float2(3.1f, -5.3f)), 0.0001f);
             TestUtils.AreEqual(true, all(isnan(normalize(float2(0.0f, 0.0f)))));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void normalize_float3()
         {
             TestUtils.AreEqual(float3(0.464916f, -0.794861f, 0.389932f), normalizesafe(float3(3.1f, -5.3f, 2.6f)), 0.0001f);
             TestUtils.AreEqual(true, all(isnan(normalize(float3(0.0f, 0.0f, 0.0f)))));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void normalize_float4()
         {
             TestUtils.AreEqual(float4(0.234727f, -0.401308f, 0.196868f, 0.863191f), normalizesafe(float4(3.1f, -5.3f, 2.6f, 11.4f)), 0.0001f);
@@ -575,28 +575,28 @@ public static void normalize_float4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void normalize_double2()
         {
             TestUtils.AreEqual(double2(0.504883, -0.863188), normalize(double2(3.1, -5.3)), 0.0001);
             TestUtils.AreEqual(true, all(isnan(normalize(double2(0.0, 0.0)))));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void normalize_double3()
         {
             TestUtils.AreEqual(double3(0.464916, -0.794861, 0.389932), normalizesafe(double3(3.1, -5.3, 2.6)), 0.0001);
             TestUtils.AreEqual(true, all(isnan(normalize(double3(0.0, 0.0, 0.0)))));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void normalize_double4()
         {
             TestUtils.AreEqual(double4(0.234727, -0.401308, 0.196868, 0.863191), normalizesafe(double4(3.1, -5.3, 2.6, 11.4)), 0.0001);
             TestUtils.AreEqual(true, all(isnan(normalize(double4(0.0, 0.0, 0.0, 0.0f)))));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void normalize_quaternion()
         {
             TestUtils.AreEqual(quaternion(0.234727f, -0.401308f, 0.196868f, 0.863191f), normalizesafe(quaternion(3.1f, -5.3f, 2.6f, 11.4f)), 0.0001f);
@@ -604,7 +604,7 @@ public static void normalize_quaternion()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void normalizesafe_float2()
         {
             TestUtils.AreEqual(float2(0.504883f, -0.863188f), normalizesafe(float2(3.1f, -5.3f)), 0.0001f);
@@ -614,7 +614,7 @@ public static void normalizesafe_float2()
             TestUtils.AreEqual(float2(1.0f, 2.0f), normalizesafe(float2(7.66e-20f, 7.66e-20f), float2(1.0f, 2.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void normalizesafe_float3()
         {
             TestUtils.AreEqual(float3(0.464916f, -0.794861f, 0.389932f), normalizesafe(float3(3.1f, -5.3f, 2.6f)), 0.0001f);
@@ -624,7 +624,7 @@ public static void normalizesafe_float3()
             TestUtils.AreEqual(float3(1.0f, 2.0f, 3.0f), normalizesafe(float3(6.25e-20f, 6.25e-20f, 6.25e-20f), float3(1.0f, 2.0f, 3.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void normalizesafe_float4()
         {
             TestUtils.AreEqual(float4(0.234727f, -0.401308f, 0.196868f, 0.863191f), normalizesafe(float4(3.1f, -5.3f, 2.6f, 11.4f)), 0.0001f);
@@ -635,7 +635,7 @@ public static void normalizesafe_float4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void normalizesafe_double2()
         {
             TestUtils.AreEqual(double2(0.504883, -0.863188), normalizesafe(double2(3.1, -5.3)), 0.0001);
@@ -645,7 +645,7 @@ public static void normalizesafe_double2()
             TestUtils.AreEqual(double2(1.0, 2.0), normalizesafe(double2(1.05e-154, 1.05e-154), double2(1.0, 2.0)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void normalizesafe_double3()
         {
             TestUtils.AreEqual(double3(0.464916, -0.794861, 0.389932), normalizesafe(double3(3.1, -5.3, 2.6)), 0.0001);
@@ -655,7 +655,7 @@ public static void normalizesafe_double3()
             TestUtils.AreEqual(double3(1.0, 2.0, 3.0), normalizesafe(double3(8.61e-155, 8.61e-155, 8.61e-155), double3(1.0, 2.0, 3.0)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void normalizesafe_double4()
         {
             TestUtils.AreEqual(double4(0.234727, -0.401308, 0.196868, 0.863191), normalizesafe(double4(3.1, -5.3, 2.6, 11.4)), 0.0001);
@@ -665,7 +665,7 @@ public static void normalizesafe_double4()
             TestUtils.AreEqual(double4(1.0, 2.0, 3.0, 4.0), normalizesafe(double4(7.45e-155, 7.45e-155, 7.45e-155, 7.45e-155), double4(1.0, 2.0, 3.0, 4.0)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void normalizesafe_quaternion()
         {
             TestUtils.AreEqual(quaternion(0.234727f, -0.401308f, 0.196868f, 0.863191f), normalizesafe(quaternion(3.1f, -5.3f, 2.6f, 11.4f)), 0.0001f);
@@ -675,7 +675,7 @@ public static void normalizesafe_quaternion()
             TestUtils.AreEqual(quaternion(1.0f, 2.0f, 3.0f, 4.0f), normalizesafe(quaternion(5.42e-20f, 5.42e-20f, 5.42e-20f, 5.42e-20f), quaternion(1.0f, 2.0f, 3.0f, 4.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void f16tof32_float()
         {
             TestUtils.AreEqual(0x00000000, asuint(f16tof32(0x0000)));
@@ -693,7 +693,7 @@ public static void f16tof32_float()
             TestUtils.AreEqual(true, isnan(f16tof32(0xFC01)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void f16tof32_float2()
         {
             TestUtils.AreEqual(uint2(0x00000000, 0x3800C000), asuint(f16tof32(uint2(0x0000, 0x0203))));
@@ -707,7 +707,7 @@ public static void f16tof32_float2()
             TestUtils.AreEqual(true, all(isnan(f16tof32(uint2(0xFC01, 0xFC01)))));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void f16tof32_float3()
         {
             TestUtils.AreEqual(uint3(0x00000000, 0x3800C000, 0x40642000), asuint(f16tof32(uint3(0x0000, 0x0203, 0x4321))));
@@ -719,7 +719,7 @@ public static void f16tof32_float3()
             TestUtils.AreEqual(true, all(isnan(f16tof32(uint3(0xFC01, 0xFC01, 0xFC01)))));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void f16tof32_float4()
         {
             TestUtils.AreEqual(uint4(0x00000000, 0x3800C000, 0x40642000, 0x477FE000), asuint(f16tof32(uint4(0x0000, 0x0203, 0x4321, 0x7BFF))));
@@ -731,7 +731,7 @@ public static void f16tof32_float4()
             TestUtils.AreEqual(true, all(isnan(f16tof32(uint4(0xFC01, 0xFC01, 0xFC01, 0xFC01)))));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void f32tof16_float()
         {
             TestUtils.AreEqual(0x0000, f32tof16(0.0f));
@@ -751,14 +751,14 @@ public static void f32tof16_float()
             TestUtils.AreEqual(0xFC00, f32tof16(float.NegativeInfinity));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void f32tof16_float_signed_zero()
         {
             TestUtils.AreEqual(0x8000, f32tof16(TestUtils.SignedFloatZero()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void f32tof16_float2()
         {
             TestUtils.AreEqual(uint2(0x0000, 0x0000), f32tof16(float2(0.0f, 2.98e-08f)));
@@ -772,14 +772,14 @@ public static void f32tof16_float2()
             TestUtils.AreEqual(uint2(0xFC00, 0x0000), f32tof16(float2(float.NegativeInfinity, 0.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void f32tof16_float2_signed_zero()
         {
             TestUtils.AreEqual(uint2(0x8000, 0x8000), f32tof16(float2(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void f32tof16_float3()
         {
             TestUtils.AreEqual(uint3(0x0000, 0x0000, 0x0001), f32tof16(float3(0.0f, 2.98e-08f, 5.96046448e-08f)));
@@ -790,14 +790,14 @@ public static void f32tof16_float3()
             TestUtils.AreEqual(uint3(0xFC00, 0xFC00, 0x0000), f32tof16(float3(-65520.0f, float.NegativeInfinity, 0.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void f32tof16_float3_signed_zero()
         {
             TestUtils.AreEqual(uint3(0x8000, 0x8000, 0x8000), f32tof16(float3(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void f32tof16_float4()
         {
             TestUtils.AreEqual(uint4(0x0000, 0x0000, 0x0001, 0x57B6), f32tof16(float4(0.0f, 2.98e-08f, 5.96046448e-08f, 123.4f)));
@@ -806,14 +806,14 @@ public static void f32tof16_float4()
             TestUtils.AreEqual(uint4(0xFC00, 0xFC00, 0xFC00, 0x0000), f32tof16(float4(-65520.0f, float.NegativeInfinity, float.NegativeInfinity, 0.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void f32tof16_float4_signed_zero()
         {
             TestUtils.AreEqual(uint4(0x8000, 0x8000, 0x8000, 0x8000), f32tof16(float4(TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero(), TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void reflect_float2()
         {
             TestUtils.AreEqual(float2(9.84f, -3.888f), reflect(float2(1.2f, 3.6f), float2(1.5f, -1.3f)), 8, false);
@@ -822,7 +822,7 @@ public static void reflect_float2()
             TestUtils.AreEqual(float2(0.0f, 0.0f), reflect(float2(0.0f, 0.0f), float2(-1.5f, -1.3f)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void reflect_float3()
         {
             TestUtils.AreEqual(float3(35.88f, -26.456f, 68.872f), reflect(float3(1.2f, 3.6f, -2.8f), float3(1.5f, -1.3f, 3.1f)), 8, false);
@@ -831,7 +831,7 @@ public static void reflect_float3()
             TestUtils.AreEqual(float3(0.0f, 0.0f, 0.0f), reflect(float3(0.0f, 0.0f, 0.0f), float3(-1.5f, -1.3f, 3.1f)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void reflect_float4()
         {
             TestUtils.AreEqual(float4(36.51f, -27.002f, 70.174f, -16.178f), reflect(float4(1.2f, 3.6f, -2.8f, 0.3f), float4(1.5f, -1.3f, 3.1f, -0.7f)), 8, false);
@@ -841,7 +841,7 @@ public static void reflect_float4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void reflect_double2()
         {
             TestUtils.AreEqual(double2(9.84, -3.888), reflect(double2(1.2, 3.6), double2(1.5, -1.3)), 8, false);
@@ -850,7 +850,7 @@ public static void reflect_double2()
             TestUtils.AreEqual(double2(0.0, 0.0), reflect(double2(0.0, 0.0), double2(-1.5, -1.3)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void reflect_double3()
         {
             TestUtils.AreEqual(double3(35.88, -26.456, 68.872), reflect(double3(1.2, 3.6, -2.8), double3(1.5, -1.3, 3.1)), 8, false);
@@ -859,7 +859,7 @@ public static void reflect_double3()
             TestUtils.AreEqual(double3(0.0, 0.0, 0.0), reflect(double3(0.0, 0.0, 0.0), double3(-1.5f, -1.3, 3.1)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void reflect_double4()
         {
             TestUtils.AreEqual(double4(36.51, -27.002, 70.174, -16.178), reflect(double4(1.2, 3.6, -2.8, 0.3), double4(1.5, -1.3, 3.1, -0.7)), 8, false);
@@ -869,7 +869,7 @@ public static void reflect_double4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void refract_float2()
         {
             TestUtils.AreEqual(float2(-0.3676186f, 0.9299768f), refract(float2(0.316228f, 0.948683f), float2(0.755689f, -0.654931f), 0.5f), 8, false);
@@ -877,7 +877,7 @@ public static void refract_float2()
             TestUtils.AreEqual(float2(0.0f, 0.0f), refract(float2(0.316228f, 0.948683f), float2(0.755689f, -0.654931f), 1.5f));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void refract_float3()
         {
             TestUtils.AreEqual(float3(-0.2863437f, 0.8056898f, -0.5185286f), refract(float3(0.288375f, 0.865125f, -0.410365f), float3(0.662147f, -0.573861f, 0.481919f), 0.5f), 8, false);
@@ -885,7 +885,7 @@ public static void refract_float3()
             TestUtils.AreEqual(float3(0.0f, 0.0f, 0.0f), refract(float3(0.288375f, 0.865125f, -0.410365f), float3(0.662147f, -0.573861f, 0.481919f), 1.5f));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void refract_float4()
         {
             TestUtils.AreEqual(float4(-0.302029191645545f, 0.799522577847971f, -0.518952508802814f, -0.015196476378571f), refract(float4(0.278154f, 0.834461f, -0.39582f, -0.26388f), float4(0.652208f, -0.565247f, 0.474685f, -0.1726139f), 0.5f), 16, false);
@@ -894,7 +894,7 @@ public static void refract_float4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void refract_double2()
         {
             TestUtils.AreEqual(double2(-0.367618540673032, 0.929976739623085), refract(double2(0.316228, 0.948683), double2(0.755689, -0.654931), 0.5), 8, false);
@@ -902,7 +902,7 @@ public static void refract_double2()
             TestUtils.AreEqual(double2(0.0, 0.0), refract(double2(0.316228, 0.948683), double2(0.755689, -0.654931), 1.5));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void refract_double3()
         {
             TestUtils.AreEqual(double3(-0.286343746291412, 0.805689753507206, -0.518528611485079), refract(double3(0.288375, 0.865125, -0.410365), double3(0.662147, -0.573861, 0.481919), 0.5), 8, false);
@@ -910,7 +910,7 @@ public static void refract_double3()
             TestUtils.AreEqual(double3(0.0, 0.0, 0.0), refract(double3(0.288375, 0.865125, -0.410365), double3(0.662147, -0.573861, 0.481919), 1.5));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void refract_double4()
         {
             TestUtils.AreEqual(double4(-0.302029191645545, 0.799522577847971, -0.518952508802814, -0.015196476378571), refract(double4(0.278154, 0.834461, -0.39582, -0.26388), double4(0.652208, -0.565247, 0.474685, -0.1726139), 0.5), 16, false);
@@ -918,7 +918,7 @@ public static void refract_double4()
             TestUtils.AreEqual(double4(0.0, 0.0, 0.0, 0.0), refract(double4(0.278154, 0.834461, -0.39582, -0.26388), double4(0.652208, -0.565247, 0.474685, -0.172613), 1.5));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void project_float2()
         {
             var a = float2(-0.161021441221237182617f, 0.429202795028686523438f);
@@ -927,7 +927,7 @@ public static void project_float2()
             TestUtils.AreEqual(float2(1.0f, 0.0f), project(float2(1.0f), float2(1.0f, 0.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void project_float3()
         {
             var a = float3(0.394884318113327026367f, 0.148208647966384887695f, -0.264224529266357421875f);
@@ -936,7 +936,7 @@ public static void project_float3()
             TestUtils.AreEqual(float3(1.0f, 0.0f, 0.0f), project(float3(1.0f), float3(1.0f, 0.0f, 0.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void project_float4()
         {
             var a = float4(0.122686818242073059082f, 0.465182095766067504883f, -0.388583064079284667969f, -0.15201015770435333252f);
@@ -945,7 +945,7 @@ public static void project_float4()
             TestUtils.AreEqual(float4(1.0f, 0.0f, 0.0f, 0.0f), project(float4(1.0f), float4(1.0f, 0.0f, 0.0f, 0.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void projectsafe_float2()
         {
             var a = float2(-0.161021441221237182617f, 0.429202795028686523438f);
@@ -957,7 +957,7 @@ public static void projectsafe_float2()
             TestUtils.AreEqual(float2(4.0f), projectsafe(float2(NAN), float2(0.0f), float2(4.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void projectsafe_float3()
         {
             var a = float3(0.394884318113327026367f, 0.148208647966384887695f, -0.264224529266357421875f);
@@ -969,7 +969,7 @@ public static void projectsafe_float3()
             TestUtils.AreEqual(float3(4.0f), projectsafe(float3(NAN), float3(0.0f), float3(4.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void projectsafe_float4()
         {
             var a = float4(0.122686818242073059082f, 0.465182095766067504883f, -0.388583064079284667969f, -0.15201015770435333252f);
@@ -981,7 +981,7 @@ public static void projectsafe_float4()
             TestUtils.AreEqual(float4(4.0f), projectsafe(float4(NAN), float4(0.0f), float4(4.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void project_double2()
         {
             var a = double2(-0.435219509355847911092, -0.359623376546357509387);
@@ -991,7 +991,7 @@ public static void project_double2()
             TestUtils.AreEqual(double2.zero, projectsafe(a, double2(DBL_MIN_NORMAL)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void project_double3()
         {
             var a = double3(-0.3102470377532390855, -0.255432695780735075086, -0.180834679740036918805);
@@ -1001,7 +1001,7 @@ public static void project_double3()
             TestUtils.AreEqual(double3.zero, projectsafe(a, double3(DBL_MIN_NORMAL)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void project_double4()
         {
             var a = double4(0.452051837682779789063, -0.0365627422588526429514, 0.236716008642456676725, 0.397823192622046239997);
@@ -1011,7 +1011,7 @@ public static void project_double4()
             TestUtils.AreEqual(double4.zero, projectsafe(a, double4(DBL_MIN_NORMAL)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void projectsafe_double2()
         {
             var a = double2(-0.435219509355847911092, -0.359623376546357509387);
@@ -1023,7 +1023,7 @@ public static void projectsafe_double2()
             TestUtils.AreEqual(double2(4.0), projectsafe(double2(NAN_DBL), double2(0.0), double2(4.0)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void projectsafe_double3()
         {
             var a = double3(-0.3102470377532390855, -0.255432695780735075086, -0.180834679740036918805);
@@ -1035,7 +1035,7 @@ public static void projectsafe_double3()
             TestUtils.AreEqual(double3(4.0), projectsafe(double3(NAN_DBL), double3(0.0), double3(4.0)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void projectsafe_double4()
         {
             var a = double4(0.452051837682779789063, -0.0365627422588526429514, 0.236716008642456676725, 0.397823192622046239997);
@@ -1047,7 +1047,7 @@ public static void projectsafe_double4()
             TestUtils.AreEqual(double4(4.0), projectsafe(double4(NAN_DBL), double4(0.0), double4(4.0)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sincos_float()
         {
             float s, c;
@@ -1086,7 +1086,7 @@ public static void sincos_float()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sincos_float2()
         {
             float2 s, c;
@@ -1108,7 +1108,7 @@ public static void sincos_float2()
             TestUtils.AreEqual(float2(float.NaN, float.NaN), c, 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sincos_float3()
         {
             float3 s, c;
@@ -1126,7 +1126,7 @@ public static void sincos_float3()
             TestUtils.AreEqual(float3(float.NaN, float.NaN, float.NaN), c, 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sincos_float4()
         {
             float4 s, c;
@@ -1140,7 +1140,7 @@ public static void sincos_float4()
             TestUtils.AreEqual(float4(0.936752141f, float.NaN, float.NaN, float.NaN), c, 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sincos_double()
         {
             double s, c;
@@ -1177,7 +1177,7 @@ public static void sincos_double()
             TestUtils.AreEqual(double.NaN, c, 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sincos_double2()
         {
             double2 s, c;
@@ -1198,7 +1198,7 @@ public static void sincos_double2()
             TestUtils.AreEqual(double2(double.NaN, double.NaN), c, 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sincos_double3()
         {
             double3 s, c;
@@ -1216,7 +1216,7 @@ public static void sincos_double3()
             TestUtils.AreEqual(double3(double.NaN, double.NaN, double.NaN), c, 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sincos_double4()
         {
             double4 s, c;
@@ -1230,14 +1230,14 @@ public static void sincos_double4()
             TestUtils.AreEqual(double4(0.93675212753314474, double.NaN, double.NaN, double.NaN), c, 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_int()
         {
             TestUtils.AreEqual(-123456789, select(-123456789, 987654321, false));
             TestUtils.AreEqual(987654321, select(-123456789, 987654321, true));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_int2()
         {
             TestUtils.AreEqual(int2(-123456789, -123456790), select(int2(-123456789, -123456790), int2(987654321, 987654322), false));
@@ -1249,7 +1249,7 @@ public static void select_int2()
             TestUtils.AreEqual(int2(987654321, 987654322), select(int2(-123456789, -123456790), int2(987654321, 987654322), bool2(true, true)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_int3()
         {
             TestUtils.AreEqual(int3(-123456789, -123456790, -123456791), select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), false));
@@ -1266,7 +1266,7 @@ public static void select_int3()
             TestUtils.AreEqual(int3(987654321, 987654322, 987654323), select(int3(-123456789, -123456790, -123456791), int3(987654321, 987654322, 987654323), bool3(true, true, true)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_int4()
         {
             TestUtils.AreEqual(int4(-123456789, -123456790, -123456791, -123456792), select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), false));
@@ -1293,14 +1293,14 @@ public static void select_int4()
             TestUtils.AreEqual(int4(987654321, 987654322, 987654323, 987654324), select(int4(-123456789, -123456790, -123456791, -123456792), int4(987654321, 987654322, 987654323, 987654324), bool4(true, true, true, true)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_uint()
         {
             TestUtils.AreEqual(123456789u, select(123456789u, 987654321u, false));
             TestUtils.AreEqual(987654321u, select(123456789u, 987654321u, true));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_uint2()
         {
             TestUtils.AreEqual(uint2(123456789u, 123456790u), select(uint2(123456789u, 123456790u), uint2(987654321u, 987654322u), false));
@@ -1312,7 +1312,7 @@ public static void select_uint2()
             TestUtils.AreEqual(uint2(987654321u, 987654322u), select(uint2(123456789u, 123456790u), uint2(987654321u, 987654322u), bool2(true, true)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_uint3()
         {
             TestUtils.AreEqual(uint3(123456789u, 123456790u, 123456791u), select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), false));
@@ -1329,7 +1329,7 @@ public static void select_uint3()
             TestUtils.AreEqual(uint3(987654321u, 987654322u, 987654323u), select(uint3(123456789u, 123456790u, 123456791u), uint3(987654321u, 987654322u, 987654323u), bool3(true, true, true)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_uint4()
         {
             TestUtils.AreEqual(uint4(123456789u, 123456790u, 123456791u, 123456792u), select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), false));
@@ -1356,14 +1356,14 @@ public static void select_uint4()
             TestUtils.AreEqual(uint4(987654321u, 987654322u, 987654323u, 987654324u), select(uint4(123456789u, 123456790u, 123456791u, 123456792u), uint4(987654321u, 987654322u, 987654323u, 987654324u), bool4(true, true, true, true)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_long()
         {
             TestUtils.AreEqual(-12345678910111314L, select(-12345678910111314L, 987654321011121314L, false));
             TestUtils.AreEqual(987654321011121314L, select(-12345678910111314L, 987654321011121314L, true));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_ulong()
         {
             TestUtils.AreEqual(12345678910111314UL, select(12345678910111314UL, 987654321011121314UL, false));
@@ -1371,14 +1371,14 @@ public static void select_ulong()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_float()
         {
             TestUtils.AreEqual(-1234.5f, select(-1234.5f, 9876.25f, false));
             TestUtils.AreEqual(9876.25f, select(-1234.5f, 9876.25f, true));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_float2()
         {
             TestUtils.AreEqual(float2(-1234.5f, -1235.5f), select(float2(-1234.5f, -1235.5f), float2(9876.25f, 9877.25f), false));
@@ -1390,7 +1390,7 @@ public static void select_float2()
             TestUtils.AreEqual(float2(9876.25f, 9877.25f), select(float2(-1234.5f, -1235.5f), float2(9876.25f, 9877.25f), bool2(true, true)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_float3()
         {
             TestUtils.AreEqual(float3(-1234.5f, -1235.5f, -1236.5f), select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), false));
@@ -1407,7 +1407,7 @@ public static void select_float3()
             TestUtils.AreEqual(float3(9876.25f, 9877.25f, 9878.25f), select(float3(-1234.5f, -1235.5f, -1236.5f), float3(9876.25f, 9877.25f, 9878.25f), bool3(true, true, true)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_float4()
         {
             TestUtils.AreEqual(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), select(float4(-1234.5f, -1235.5f, -1236.5f, -1237.5f), float4(9876.25f, 9877.25f, 9878.25f, 9879.25f), false));
@@ -1435,14 +1435,14 @@ public static void select_float4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_double()
         {
             TestUtils.AreEqual(-1234.5, select(-1234.5, 9876.25, false));
             TestUtils.AreEqual(9876.25, select(-1234.5, 9876.25, true));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_double2()
         {
             TestUtils.AreEqual(double2(-1234.5, -1235.5), select(double2(-1234.5, -1235.5), double2(9876.25, 9877.25), false));
@@ -1454,7 +1454,7 @@ public static void select_double2()
             TestUtils.AreEqual(double2(9876.25, 9877.25), select(double2(-1234.5, -1235.5), double2(9876.25, 9877.25), bool2(true, true)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_double3()
         {
             TestUtils.AreEqual(double3(-1234.5, -1235.5, -1236.5), select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), false));
@@ -1471,7 +1471,7 @@ public static void select_double3()
             TestUtils.AreEqual(double3(9876.25, 9877.25, 9878.25), select(double3(-1234.5, -1235.5, -1236.5), double3(9876.25, 9877.25, 9878.25), bool3(true, true, true)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void select_double4()
         {
             TestUtils.AreEqual(double4(-1234.5, -1235.5, -1236.5, -1237.5), select(double4(-1234.5, -1235.5, -1236.5, -1237.5), double4(9876.25, 9877.25, 9878.25, 9879.25), false));
@@ -1499,7 +1499,7 @@ public static void select_double4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void dot_int()
         {
             TestUtils.AreEqual(133, dot(7, 19));
@@ -1508,7 +1508,7 @@ public static void dot_int()
             TestUtils.AreEqual(667585376, dot(61031, 81312));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void dot_int2()
         {
             TestUtils.AreEqual(322, dot(int2(7, 9), int2(19, 21)));
@@ -1517,7 +1517,7 @@ public static void dot_int2()
             TestUtils.AreEqual(1840235232, dot(int2(61031, -12534), int2(-41312, -5312)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void dot_int3()
         {
             TestUtils.AreEqual(582, dot(int3(7, 9, 13), int3(19, 21, 20)));
@@ -1526,7 +1526,7 @@ public static void dot_int3()
             TestUtils.AreEqual(1636460279, dot(int3(61031, -12534, 9211), int3(-41312, -5312, -22123)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void dot_int4()
         {
             TestUtils.AreEqual(990, dot(int4(7, 9, 13, 17), int4(19, 21, 20, 24)));
@@ -1536,28 +1536,28 @@ public static void dot_int4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void dot_uint()
         {
             TestUtils.AreEqual(133u, dot(7u, 19u));
             TestUtils.AreEqual(667585376u, dot(61031u, 81312u));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void dot_uint2()
         {
             TestUtils.AreEqual(322, dot(uint2(7u, 9u), uint2(19u, 21u)));
             TestUtils.AreEqual(734165984u, dot(uint2(61031u, 12534u), uint2(81312u, 5312u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void dot_uint3()
         {
             TestUtils.AreEqual(582u, dot(uint3(7u, 9u, 13u), uint3(19u, 21u, 20u)));
             TestUtils.AreEqual(937940937u, dot(uint3(61031u, 12534u, 9211u), uint3(81312u, 5312u, 22123u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void dot_uint4()
         {
             TestUtils.AreEqual(990u, dot(uint4(7u, 9u, 13u, 17u), uint4(19u, 21u, 20u, 24u)));
@@ -1565,7 +1565,7 @@ public static void dot_uint4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void dot_float()
         {
             TestUtils.AreEqual(7.32f, dot(1.2f, 6.1f), 1, false);
@@ -1576,7 +1576,7 @@ public static void dot_float()
             TestUtils.AreEqual(float.NegativeInfinity, dot(1.2e19f, -6.1e19f), 0, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void dot_float2()
         {
             TestUtils.AreEqual(57.92f, dot(float2(1.2f, 5.5f), float2(6.1f, 9.2f)), 1, false);
@@ -1587,7 +1587,7 @@ public static void dot_float2()
             TestUtils.AreEqual(float.NegativeInfinity, dot(float2(-1.2e18f, 5.5e18f), float2(6.1e19f, -9.2e19f)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void dot_float3()
         {
             TestUtils.AreEqual(67.1f, dot(float3(1.2f, 5.5f, 3.4f), float3(6.1f, 9.2f, 2.7f)), 8, false);
@@ -1598,7 +1598,7 @@ public static void dot_float3()
             TestUtils.AreEqual(float.NegativeInfinity, dot(float3(-1.2e18f, 5.5e18f, 3.4e18f), float3(6.1e19f, -9.2e19f, -2.7e19f)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void dot_float4()
         {
             TestUtils.AreEqual(68.57f, dot(float4(1.2f, 5.5f, 3.4f, 4.9f), float4(6.1f, 9.2f, 2.7f, 0.3f)), 8, false);
@@ -1620,7 +1620,7 @@ public static void dot_double()
             TestUtils.AreEqual(double.NegativeInfinity, dot(1.2e19, -6.1e19), 0, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void dot_double2()
         {
             TestUtils.AreEqual(57.92, dot(double2(1.2, 5.5), double2(6.1, 9.2)), 1, false);
@@ -1631,7 +1631,7 @@ public static void dot_double2()
             TestUtils.AreEqual(double.NegativeInfinity, dot(double2(-1.2e153, 5.5e153), double2(6.1e154, -9.2e154)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void dot_double3()
         {
             TestUtils.AreEqual(67.1, dot(double3(1.2, 5.5, 3.4), double3(6.1, 9.2, 2.7)), 8, false);
@@ -1642,7 +1642,7 @@ public static void dot_double3()
             TestUtils.AreEqual(double.NegativeInfinity, dot(double3(-1.2e153, 5.5e153, 3.4e153), double3(6.1e154, -9.2e154, -2.7e154)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void dot_double4()
         {
             TestUtils.AreEqual(68.57, dot(double4(1.2, 5.5, 3.4, 4.9), double4(6.1, 9.2, 2.7, 0.3)), 8, false);
@@ -1653,7 +1653,7 @@ public static void dot_double4()
             TestUtils.AreEqual(double.NegativeInfinity, dot(double4(-1.2e153, 5.5e153, 3.4e153, -4.9e153), double4(6.1e154, -9.2e154, -2.7e154, 3e153)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmin_int2()
         {
             TestUtils.AreEqual(100, cmin(int2(100, 200)));
@@ -1664,7 +1664,7 @@ public static void cmin_int2()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmin_int3()
         {
             TestUtils.AreEqual(100, cmin(int3(100, 200, 300)));
@@ -1675,7 +1675,7 @@ public static void cmin_int3()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmin_int4()
         {
             TestUtils.AreEqual(100, cmin(int4(100, 200, 300, 400)));
@@ -1685,7 +1685,7 @@ public static void cmin_int4()
             TestUtils.AreEqual(int.MinValue, cmin(int4(int.MaxValue, int.MinValue, 0, 19)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmin_uint2()
         {
             TestUtils.AreEqual(100u, cmin(uint2(100u, 200u)));
@@ -1694,7 +1694,7 @@ public static void cmin_uint2()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmin_uint3()
         {
             TestUtils.AreEqual(100u, cmin(uint3(100u, 200u, 300u)));
@@ -1703,7 +1703,7 @@ public static void cmin_uint3()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmin_uint4()
         {
             TestUtils.AreEqual(100u, cmin(uint4(100u, 200u, 300u, 400u)));
@@ -1711,7 +1711,7 @@ public static void cmin_uint4()
             TestUtils.AreEqual(uint.MinValue, cmin(uint4(19u, uint.MinValue, uint.MaxValue, 7u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmin_float2()
         {
             TestUtils.AreEqual(-0.5f, cmin(float2(5.2f, -0.5f)));
@@ -1730,7 +1730,7 @@ public static void cmin_float2()
             TestUtils.AreEqual(float.NegativeInfinity, cmin(float2(float.NaN, float.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmin_float3()
         {
             TestUtils.AreEqual(-1.2f, cmin(float3(5.2f, -0.5f, -1.2f)));
@@ -1750,7 +1750,7 @@ public static void cmin_float3()
             TestUtils.AreEqual(float.NegativeInfinity, cmin(float3(float.NaN, float.NaN, float.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmin_float4()
         {
             TestUtils.AreEqual(-1.2f, cmin(float4(5.2f, -0.5f, -1.2f, 2.3f)));
@@ -1773,7 +1773,7 @@ public static void cmin_float4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmin_double2()
         {
             TestUtils.AreEqual(-0.5, cmin(double2(5.2, -0.5)));
@@ -1793,7 +1793,7 @@ public static void cmin_double2()
             TestUtils.AreEqual(double.NegativeInfinity, cmin(double2(double.NaN, double.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmin_double3()
         {
             TestUtils.AreEqual(-1.2, cmin(double3(5.2, -0.5, -1.2)));
@@ -1814,7 +1814,7 @@ public static void cmin_double3()
             TestUtils.AreEqual(double.NegativeInfinity, cmin(double3(double.NaN, double.NaN, double.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmin_double4()
         {
             TestUtils.AreEqual(-1.2, cmin(double4(5.2, -0.5, -1.2, 2.3)));
@@ -1839,7 +1839,7 @@ public static void cmin_double4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmax_int2()
         {
             TestUtils.AreEqual(200, cmax(int2(100, 200)));
@@ -1850,7 +1850,7 @@ public static void cmax_int2()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmax_int3()
         {
             TestUtils.AreEqual(300, cmax(int3(100, 200, 300)));
@@ -1861,7 +1861,7 @@ public static void cmax_int3()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmax_int4()
         {
             TestUtils.AreEqual(400, cmax(int4(100, 200, 300, 400)));
@@ -1871,7 +1871,7 @@ public static void cmax_int4()
             TestUtils.AreEqual(int.MaxValue, cmax(int4(int.MaxValue, int.MinValue, 0, 19)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmax_uint2()
         {
             TestUtils.AreEqual(200u, cmax(uint2(100u, 200u)));
@@ -1880,7 +1880,7 @@ public static void cmax_uint2()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmax_uint3()
         {
             TestUtils.AreEqual(300u, cmax(uint3(100u, 200u, 300u)));
@@ -1889,7 +1889,7 @@ public static void cmax_uint3()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmax_uint4()
         {
             TestUtils.AreEqual(400u, cmax(uint4(100u, 200u, 300u, 400u)));
@@ -1897,7 +1897,7 @@ public static void cmax_uint4()
             TestUtils.AreEqual(uint.MaxValue, cmax(uint4(19u, uint.MinValue, uint.MaxValue, 7u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmax_float2()
         {
             TestUtils.AreEqual(5.2f, cmax(float2(5.2f, -0.5f)));
@@ -1916,7 +1916,7 @@ public static void cmax_float2()
             TestUtils.AreEqual(float.NegativeInfinity, cmax(float2(float.NaN, float.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmax_float3()
         {
             TestUtils.AreEqual(5.2f, cmax(float3(5.2f, -0.5f, -1.2f)));
@@ -1936,7 +1936,7 @@ public static void cmax_float3()
             TestUtils.AreEqual(float.NegativeInfinity, cmax(float3(float.NaN, float.NaN, float.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmax_float4()
         {
             TestUtils.AreEqual(5.2f, cmax(float4(5.2f, -0.5f, -1.2f, 2.3f)));
@@ -1959,7 +1959,7 @@ public static void cmax_float4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmax_double2()
         {
             TestUtils.AreEqual(5.2, cmax(double2(5.2, -0.5)));
@@ -1979,7 +1979,7 @@ public static void cmax_double2()
             TestUtils.AreEqual(double.NegativeInfinity, cmax(double2(double.NaN, double.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmax_double3()
         {
             TestUtils.AreEqual(5.2, cmax(double3(5.2, -0.5, -1.2)));
@@ -2000,7 +2000,7 @@ public static void cmax_double3()
             TestUtils.AreEqual(double.NegativeInfinity, cmax(double3(double.NaN, double.NaN, double.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cmax_double4()
         {
             TestUtils.AreEqual(5.2, cmax(double4(5.2, -0.5, -1.2, 2.3)));
@@ -2024,7 +2024,7 @@ public static void cmax_double4()
             TestUtils.AreEqual(double.NegativeInfinity, cmax(double4(double.NaN, double.NaN, double.NaN, double.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void csum_int2()
         {
             TestUtils.AreEqual(300, csum(int2(100, 200)));
@@ -2035,7 +2035,7 @@ public static void csum_int2()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void csum_int3()
         {
             TestUtils.AreEqual(600, csum(int3(100, 200, 300)));
@@ -2046,7 +2046,7 @@ public static void csum_int3()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void csum_int4()
         {
             TestUtils.AreEqual(1000, csum(int4(100, 200, 300, 400)));
@@ -2056,7 +2056,7 @@ public static void csum_int4()
             TestUtils.AreEqual(-1, csum(int4(int.MaxValue, int.MinValue, 0, 0)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void csum_uint2()
         {
             TestUtils.AreEqual(300u, csum(uint2(100u, 200u)));
@@ -2064,7 +2064,7 @@ public static void csum_uint2()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void csum_uint3()
         {
             TestUtils.AreEqual(600u, csum(uint3(100u, 200u, 300u)));
@@ -2072,14 +2072,14 @@ public static void csum_uint3()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void csum_uint4()
         {
             TestUtils.AreEqual(1000u, csum(uint4(100u, 200u, 300u, 400u)));
             TestUtils.AreEqual(36u, csum(uint4(uint.MaxValue, 7u, 11u, 19u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void csum_float2()
         {
             TestUtils.AreEqual(0.7f, csum(float2(2.2f, -1.5f)), 4, false);
@@ -2102,7 +2102,7 @@ public static void csum_float2()
             TestUtils.AreEqual(float.NegativeInfinity, csum(float2(-1.0f, float.NegativeInfinity)), 0, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void csum_float3()
         {
             TestUtils.AreEqual(1.9f, csum(float3(2.2f, -1.5f, 1.2f)), 4, false);
@@ -2126,7 +2126,7 @@ public static void csum_float3()
             TestUtils.AreEqual(float.NegativeInfinity, csum(float3(-2.0f, 1.0f, float.NegativeInfinity)), 0, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void csum_float4()
         {
             TestUtils.AreEqual(1.2f, csum(float4(2.2f, -1.5f, 1.2f, -0.7f)), 4, false);
@@ -2153,7 +2153,7 @@ public static void csum_float4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void csum_double2()
         {
             TestUtils.AreEqual(0.7, csum(double2(2.2, -1.5)), 4, false);
@@ -2176,7 +2176,7 @@ public static void csum_double2()
             TestUtils.AreEqual(double.NegativeInfinity, csum(double2(-1.0, double.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void csum_double3()
         {
             TestUtils.AreEqual(1.9, csum(double3(2.2, -1.5, 1.2)), 4, false);
@@ -2200,7 +2200,7 @@ public static void csum_double3()
             TestUtils.AreEqual(double.NegativeInfinity, csum(double3(-2.0, 1.0, double.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void csum_double4()
         {
             TestUtils.AreEqual(1.2, csum(double4(2.2, -1.5, 1.2, -0.7)), 4, false);
@@ -2227,7 +2227,7 @@ public static void csum_double4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void any_bool2()
         {
             TestUtils.AreEqual(false, any(bool2(false, false)));
@@ -2236,7 +2236,7 @@ public static void any_bool2()
             TestUtils.AreEqual(true, any(bool2(true, true)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void any_bool3()
         {
             TestUtils.AreEqual(false, any(bool3(false, false, false)));
@@ -2250,7 +2250,7 @@ public static void any_bool3()
             TestUtils.AreEqual(true, any(bool3(true, true, true)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void any_bool4()
         {
             TestUtils.AreEqual(false, any(bool4(false, false, false, false)));
@@ -2274,7 +2274,7 @@ public static void any_bool4()
             TestUtils.AreEqual(true, any(bool4(true, true, true, true)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void any_int2()
         {
             TestUtils.AreEqual(false, any(int2(0, 0)));
@@ -2284,7 +2284,7 @@ public static void any_int2()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void any_int3()
         {
             TestUtils.AreEqual(false, any(int3(0, 0, 0)));
@@ -2298,7 +2298,7 @@ public static void any_int3()
             TestUtils.AreEqual(true, any(int3(-121, 100, 322)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void any_int4()
         {
             TestUtils.AreEqual(false, any(int4(0, 0, 0, 0)));
@@ -2323,7 +2323,7 @@ public static void any_int4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void any_uint2()
         {
             TestUtils.AreEqual(false, any(uint2(0u, 0u)));
@@ -2333,7 +2333,7 @@ public static void any_uint2()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void any_uint3()
         {
             TestUtils.AreEqual(false, any(uint3(0u, 0u, 0u)));
@@ -2347,7 +2347,7 @@ public static void any_uint3()
             TestUtils.AreEqual(true, any(uint3(121u, 100u, 322u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void any_uint4()
         {
             TestUtils.AreEqual(false, any(uint4(0u, 0u, 0u, 0u)));
@@ -2372,7 +2372,7 @@ public static void any_uint4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void any_float2()
         {
             //TestUtils.AreEqual(true, any(float2(0, float.NaN)));    // TODO: doesn't work with burst
@@ -2384,7 +2384,7 @@ public static void any_float2()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void any_float3()
         {
             //TestUtils.AreEqual(true, any(float3(0.0f, float.NaN, 0.0f)));    // TODO: doesn't work with burst
@@ -2400,7 +2400,7 @@ public static void any_float3()
             TestUtils.AreEqual(true, any(float3(121.2f, 100.0f, -32.2f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void any_float4()
         {
             TestUtils.AreEqual(false, any(float4(0.0f, 0.0f, 0.0f, 0.0f)));
@@ -2424,7 +2424,7 @@ public static void any_float4()
             TestUtils.AreEqual(true, any(float4(55.0f, 66.0f, 5000.0f, 10000.2f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void any_double2()
         {
             //TestUtils.AreEqual(true, any(double2(0, double.NaN)));    // TODO: doesn't work with burst.
@@ -2436,7 +2436,7 @@ public static void any_double2()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void any_double3()
         {
             //TestUtils.AreEqual(true, any(double3(0.0, double.NaN, 0.0)));    // TODO: doesn't work with burst
@@ -2452,7 +2452,7 @@ public static void any_double3()
             TestUtils.AreEqual(true, any(double3(121.2, 100.0, -32.2)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void any_double4()
         {
             TestUtils.AreEqual(false, any(double4(0.0, 0.0, 0.0, 0.0)));
@@ -2477,7 +2477,7 @@ public static void any_double4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void all_bool2()
         {
             TestUtils.AreEqual(false, all(bool2(false, false)));
@@ -2486,7 +2486,7 @@ public static void all_bool2()
             TestUtils.AreEqual(true, all(bool2(true, true)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void all_bool3()
         {
             TestUtils.AreEqual(false, all(bool3(false, false, false)));
@@ -2500,7 +2500,7 @@ public static void all_bool3()
             TestUtils.AreEqual(true, all(bool3(true, true, true)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void all_bool4()
         {
             TestUtils.AreEqual(false, all(bool4(false, false, false, false)));
@@ -2524,7 +2524,7 @@ public static void all_bool4()
             TestUtils.AreEqual(true, all(bool4(true, true, true, true)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void all_int2()
         {
             TestUtils.AreEqual(false, all(int2(0, 0)));
@@ -2533,7 +2533,7 @@ public static void all_int2()
             TestUtils.AreEqual(true, all(int2(2, int.MinValue)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void all_int3()
         {
             TestUtils.AreEqual(false, all(int3(0, 0, 0)));
@@ -2547,7 +2547,7 @@ public static void all_int3()
             TestUtils.AreEqual(true, all(int3(-121, 100, 322)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void all_int4()
         {
             TestUtils.AreEqual(false, all(int4(0, 0, 0, 0)));
@@ -2572,7 +2572,7 @@ public static void all_int4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void all_uint2()
         {
             TestUtils.AreEqual(false, all(uint2(0u, 0u)));
@@ -2582,7 +2582,7 @@ public static void all_uint2()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void all_uint3()
         {
             TestUtils.AreEqual(false, all(uint3(0u, 0u, 0u)));
@@ -2596,7 +2596,7 @@ public static void all_uint3()
             TestUtils.AreEqual(true, all(uint3(121u, 100u, 322u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void all_uint4()
         {
             TestUtils.AreEqual(false, all(uint4(0u, 0u, 0u, 0u)));
@@ -2621,7 +2621,7 @@ public static void all_uint4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void all_float2()
         {
             TestUtils.AreEqual(true, all(float2(float.NaN, float.NaN)));
@@ -2633,7 +2633,7 @@ public static void all_float2()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void all_float3()
         {
             TestUtils.AreEqual(true, all(float3(float.NaN, float.NaN, float.NaN)));
@@ -2649,7 +2649,7 @@ public static void all_float3()
             TestUtils.AreEqual(true, all(float3(121.2f, 100.0f, -32.2f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void all_float4()
         {
             TestUtils.AreEqual(true, all(float4(float.NaN, float.NaN, float.NaN, float.NaN)));
@@ -2675,7 +2675,7 @@ public static void all_float4()
             TestUtils.AreEqual(true, all(float4(55.0f, 66.0f, 5000.0f, 10000.2f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void all_double2()
         {
             TestUtils.AreEqual(true, all(double2(double.NaN, double.NaN)));
@@ -2687,7 +2687,7 @@ public static void all_double2()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void all_double3()
         {
             TestUtils.AreEqual(true, all(double3(double.NaN, double.NaN, double.NaN)));
@@ -2703,7 +2703,7 @@ public static void all_double3()
             TestUtils.AreEqual(true, all(double3(121.2, 100.0, -32.2)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void all_double4()
         {
             TestUtils.AreEqual(true, all(double4(double.NaN, double.NaN, double.NaN, double.NaN)));
@@ -2730,7 +2730,7 @@ public static void all_double4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void length_float2()
         {
             TestUtils.AreEqual(0.0f, length(float2(0.0f, 0.0f)), 0, false);
@@ -2743,7 +2743,7 @@ public static void length_float2()
             TestUtils.AreEqual(double.PositiveInfinity, length(float2(-1.2e19f, -2.6e19f)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void length_float3()
         {
             TestUtils.AreEqual(0.0f, length(float3(0.0f, 0.0f, 0.0f)), 0, false);
@@ -2756,7 +2756,7 @@ public static void length_float3()
             TestUtils.AreEqual(float.PositiveInfinity, length(float3(-1.2e19f, -2.6e19f, 2.2e19f)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void length_float4()
         {
             TestUtils.AreEqual(0.0f, length(float4(0.0f, 0.0f, 0.0f, 0.0f)), 0, false);
@@ -2770,7 +2770,7 @@ public static void length_float4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void length_double2()
         {
             TestUtils.AreEqual(0.0, length(double2(0.0, 0.0)), 0, false);
@@ -2782,7 +2782,7 @@ public static void length_double2()
             TestUtils.AreEqual(2.86356421265527063e153, length(double2(-1.2e153, 2.6e153)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void length_double3()
         {
             TestUtils.AreEqual(0.0, length(double3(0.0, 0.0, 0.0)), 0, false);
@@ -2794,7 +2794,7 @@ public static void length_double3()
             TestUtils.AreEqual(3.6110940170535577e153, length(double3(-1.2e153, 2.6e153, 2.2e153)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void length_double4()
         {
             TestUtils.AreEqual(0.0, length(double4(0.0, 0.0, 0.0, 0.0)), 0, false);
@@ -2807,7 +2807,7 @@ public static void length_double4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lengthsq_float2()
         {
             TestUtils.AreEqual(0.0f, lengthsq(float2(0.0f, 0.0f)), 0, false);
@@ -2819,7 +2819,7 @@ public static void lengthsq_float2()
             TestUtils.AreEqual(8.2e36f, lengthsq(float2(-1.2e18f, 2.6e18f)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lengthsq_float3()
         {
             TestUtils.AreEqual(0.0f, lengthsq(float3(0.0f, 0.0f, 0.0f)), 0, false);
@@ -2832,7 +2832,7 @@ public static void lengthsq_float3()
             TestUtils.AreEqual(float.PositiveInfinity, lengthsq(float3(-1.2e19f, -2.6e19f, 2.2e19f)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lengthsq_float4()
         {
             TestUtils.AreEqual(0.0f, lengthsq(float4(0.0f, 0.0f, 0.0f, 0.0f)), 0, false);
@@ -2846,7 +2846,7 @@ public static void lengthsq_float4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lengthsq_double2()
         {
             TestUtils.AreEqual(0.0, lengthsq(double2(0.0, 0.0)), 0, false);
@@ -2859,7 +2859,7 @@ public static void lengthsq_double2()
             TestUtils.AreEqual(double.PositiveInfinity, lengthsq(double2(-1.2e154, -2.6e154)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lengthsq_double3()
         {
             TestUtils.AreEqual(0.0, lengthsq(double3(0.0, 0.0, 0.0)), 0, false);
@@ -2872,7 +2872,7 @@ public static void lengthsq_double3()
             TestUtils.AreEqual(double.PositiveInfinity, lengthsq(double3(-1.2e154, -2.6e154, 2.2e154)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lengthsq_double4()
         {
             TestUtils.AreEqual(0.0, lengthsq(double4(0.0, 0.0, 0.0, 0.0)), 0, false);
@@ -2888,7 +2888,7 @@ public static void lengthsq_double4()
 
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void distance_float2()
         {
             TestUtils.AreEqual(0.0f, distance(float2(1.3f, -2.4f), float2(1.3f, -2.4f)), 0, false);
@@ -2902,7 +2902,7 @@ public static void distance_float2()
             TestUtils.AreEqual(float.PositiveInfinity, distance(float2(1.3f, float.NegativeInfinity), float2(-5.3f, 4.3f)), 0, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void distance_float3()
         {
             TestUtils.AreEqual(0.0f, distance(float2(1.3f, -2.4f), float2(1.3f, -2.4f)), 0, false);
@@ -2916,7 +2916,7 @@ public static void distance_float3()
             TestUtils.AreEqual(float.PositiveInfinity, distance(float2(1.3f, float.NegativeInfinity), float2(-5.3f, 4.3f)), 0, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void distance_float4()
         {
             TestUtils.AreEqual(0.0, distance(float4(1.3f, -2.4f, 5.7f, 3.1f), float4(1.3f, -2.4f, 5.7f, 3.1f)), 0, false);
@@ -2931,7 +2931,7 @@ public static void distance_float4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void distance_double2()
         {
             TestUtils.AreEqual(0.0, distance(double2(1.3, -2.4), double2(1.3, -2.4)), 0, false);
@@ -2944,7 +2944,7 @@ public static void distance_double2()
             TestUtils.AreEqual(double.PositiveInfinity, distance(double2(1.3, -2.4), double2(-5.3, double.PositiveInfinity)), 0, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void distance_double3()
         {
             TestUtils.AreEqual(0.0, distance(double2(1.3, -2.4), double2(1.3, -2.4)), 0, false);
@@ -2957,7 +2957,7 @@ public static void distance_double3()
             TestUtils.AreEqual(double.PositiveInfinity, distance(double2(1.3, -2.4), double2(-5.3, double.PositiveInfinity)), 0, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void distance_double4()
         {
             TestUtils.AreEqual(0.0, distance(double4(1.3, -2.4, 5.7, 3.1), double4(1.3, -2.4, 5.7, 3.1)), 0, false);
@@ -2970,7 +2970,7 @@ public static void distance_double4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void distancesq_float2()
         {
             TestUtils.AreEqual(0.0f, distancesq(float2(1.3f, -2.4f), float2(1.3f, -2.4f)), 0, false);
@@ -2982,7 +2982,7 @@ public static void distancesq_float2()
             TestUtils.AreEqual(float.PositiveInfinity, distancesq(float2(1.3f, -2.4f), float2(-5.3f, float.PositiveInfinity)), 0, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void distancesq_float3()
         {
             TestUtils.AreEqual(0.0f, distancesq(float3(1.3f, -2.4f, 5.7f), float3(1.3f, -2.4f, 5.7f)), 0, false);
@@ -2995,7 +2995,7 @@ public static void distancesq_float3()
             TestUtils.AreEqual(float.PositiveInfinity, distancesq(float3(1.3f, -2.4f, 5.7f), float3(-5.3f, float.PositiveInfinity, 4.7f)), 0, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void distancesq_float4()
         {
             TestUtils.AreEqual(0.0f, distancesq(float4(1.3f, -2.4f, 5.7f, 3.1f), float4(1.3f, -2.4f, 5.7f, 3.1f)), 0, false);
@@ -3008,7 +3008,7 @@ public static void distancesq_float4()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void distancesq_double2()
         {
             TestUtils.AreEqual(0.0, distancesq(double2(1.3, -2.4), double2(1.3, -2.4)), 0, false);
@@ -3022,7 +3022,7 @@ public static void distancesq_double2()
             TestUtils.AreEqual(double.PositiveInfinity, distancesq(double2(1.3, double.NegativeInfinity), double2(-5.3, 4.3)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void distancesq_double3()
         {
             TestUtils.AreEqual(0.0, distancesq(double3(1.3, -2.4, 5.7), double3(1.3, -2.4, 5.7)), 0, false);
@@ -3036,7 +3036,7 @@ public static void distancesq_double3()
             TestUtils.AreEqual(double.PositiveInfinity, distancesq(double3(1.3, double.NegativeInfinity, 5.7), double3(-5.3, 4.3, 4.7)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void distancesq_double4()
         {
             TestUtils.AreEqual(0.0, distancesq(double4(1.3, -2.4, 5.7, 3.1), double4(1.3, -2.4, 5.7, 3.1)), 0, false);
@@ -3050,7 +3050,7 @@ public static void distancesq_double4()
             TestUtils.AreEqual(double.PositiveInfinity, distancesq(double4(1.3, double.NegativeInfinity, 5.7, 3.1), double4(-5.3, 4.3, 4.7, 0.3)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void epsilon_float()
         {
             float next = asfloat(asuint(1.0f) + 1);
@@ -3059,7 +3059,7 @@ public static void epsilon_float()
             TestUtils.IsTrue(Single.Epsilon != EPSILON);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void epsilon_double()
         {
             double next = asdouble(aslong(1.0) + 1);
@@ -3068,7 +3068,7 @@ public static void epsilon_double()
             TestUtils.IsTrue(Double.Epsilon != EPSILON_DBL);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void nan_float()
         {
             TestUtils.IsFalse(0.0f == NAN);
@@ -3093,7 +3093,7 @@ public static void nan_float()
             TestUtils.IsTrue(nan1 != nan2);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void nan_double()
         {
             TestUtils.IsFalse(0.0 == NAN_DBL);
@@ -3118,7 +3118,7 @@ public static void nan_double()
             TestUtils.IsTrue(nan1 != nan2);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void infinity_float()
         {
             TestUtils.IsTrue(-INFINITY != INFINITY);
@@ -3126,7 +3126,7 @@ public static void infinity_float()
             TestUtils.IsFalse(isfinite(INFINITY));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void infinity_double()
         {
             TestUtils.IsTrue(-INFINITY_DBL != INFINITY_DBL);
@@ -3134,7 +3134,7 @@ public static void infinity_double()
             TestUtils.IsFalse(isfinite(INFINITY_DBL));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void helper_axes()
         {
             TestUtils.AreEqual(float3(1.0f, 0.0f, 0.0f), right());
@@ -3145,7 +3145,7 @@ public static void helper_axes()
             TestUtils.AreEqual(float3(0.0f, 0.0f, -1.0f), back());
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void rcp_float_signed_zero()
         {
@@ -3153,21 +3153,21 @@ public static void rcp_float_signed_zero()
             TestUtils.AreEqual(TestUtils.SignedFloatZero(), rcp(float.NegativeInfinity));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void rcp_float2_signed_zero()
         {
             TestUtils.AreEqual(float2(float.NegativeInfinity, TestUtils.SignedFloatZero()), rcp(float2(TestUtils.SignedFloatZero(), float.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void rcp_float3_signed_zero()
         {
             TestUtils.AreEqual(float3(float.NegativeInfinity, TestUtils.SignedFloatZero(), float.NegativeInfinity), rcp(float3(TestUtils.SignedFloatZero(), float.NegativeInfinity, TestUtils.SignedFloatZero())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void rcp_float4_signed_zero()
         {
@@ -3175,7 +3175,7 @@ public static void rcp_float4_signed_zero()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void rcp_double_signed_zero()
         {
@@ -3183,28 +3183,28 @@ public static void rcp_double_signed_zero()
             TestUtils.AreEqual(TestUtils.SignedDoubleZero(), rcp(double.NegativeInfinity));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void rcp_double2_signed_zero()
         {
             TestUtils.AreEqual(double2(double.NegativeInfinity, TestUtils.SignedDoubleZero()), rcp(double2(TestUtils.SignedDoubleZero(), double.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void rcp_double3_signed_zero()
         {
             TestUtils.AreEqual(double3(double.NegativeInfinity, TestUtils.SignedDoubleZero(), double.NegativeInfinity), rcp(double3(TestUtils.SignedDoubleZero(), double.NegativeInfinity, TestUtils.SignedDoubleZero())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         [WindowsOnly("Mono on linux ignores signed zero.")]
         public static void rcp_double4_signed_zero()
         {
             TestUtils.AreEqual(double4(double.NegativeInfinity, TestUtils.SignedDoubleZero(), double.NegativeInfinity, TestUtils.SignedDoubleZero()), rcp(double4(TestUtils.SignedDoubleZero(), double.NegativeInfinity, TestUtils.SignedDoubleZero(), double.NegativeInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         unsafe public static void compress_test()
         {
             int4 value = int4(0x12345678, 0x2468ACE0, 0x369BE147, 0x48C059D1);
@@ -3250,7 +3250,7 @@ unsafe public static void compress_test()
             }
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         unsafe public static void compress_uint4_test()
         {
             uint4 value = uint4(0x12345678u, 0x2468ACE0u, 0x369BE147u, 0x48C059D1u);
@@ -3296,7 +3296,7 @@ unsafe public static void compress_uint4_test()
             }
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         unsafe public static void compress_float4_test()
         {
             float4 value = float4(float.PositiveInfinity,  EPSILON, PI, -0.25f);
@@ -3342,7 +3342,7 @@ unsafe public static void compress_float4_test()
             }
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void square_float()
         {
             TestUtils.AreEqual(0.0f, math.square(0.0f));
@@ -3370,7 +3370,7 @@ public static void square_float()
             TestUtils.AreEqual(float.PositiveInfinity, math.square(-18446744073709551616.0f));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void square_float2()
         {
             TestUtils.AreEqual(new float2(0.0f), math.square(new float2(0.0f)));
@@ -3401,7 +3401,7 @@ public static void square_float2()
             TestUtils.AreEqual(new float2(0.272176146507263183594f, 96307.6015625f), math.square(new float2(0.521705031394958496094f, -310.33465576171875f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void square_float3()
         {
             TestUtils.AreEqual(new float3(0.0f), math.square(new float3(0.0f)));
@@ -3432,7 +3432,7 @@ public static void square_float3()
             TestUtils.AreEqual(new float3(0.272176146507263183594f, 96307.6015625f, 5591.6337890625f), math.square(new float3(0.521705031394958496094f, -310.33465576171875f, -74.77722930908203125f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void square_float4()
         {
             TestUtils.AreEqual(new float4(0.0f), math.square(new float4(0.0f)));
@@ -3463,7 +3463,7 @@ public static void square_float4()
             TestUtils.AreEqual(new float4(0.272176146507263183594f, 96307.6015625f, 5591.6337890625f, 152764.28125f), math.square(new float4(0.521705031394958496094f, -310.33465576171875f, -74.77722930908203125f, 390.8507080078125f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void square_double()
         {
             TestUtils.AreEqual(0.0, math.square(0.0));
@@ -3491,7 +3491,7 @@ public static void square_double()
             TestUtils.AreEqual(double.PositiveInfinity, math.square(-1.34078079299425970996e+154));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void square_double2()
         {
             TestUtils.AreEqual(new double2(0.0), math.square(new double2(0.0)));
@@ -3522,7 +3522,7 @@ public static void square_double2()
             TestUtils.AreEqual(new double2(0.272176139782814630053, 96307.5985667444765568), math.square(new double2(0.521705031394958496094, -310.33465576171875)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void square_double3()
         {
             TestUtils.AreEqual(new double3(0.0), math.square(new double3(0.0)));
@@ -3553,7 +3553,7 @@ public static void square_double3()
             TestUtils.AreEqual(new double3(0.272176139782814630053, 96307.5985667444765568, 5591.63402314303675666), math.square(new double3(0.521705031394958496094, -310.33465576171875, -74.77722930908203125)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void square_double4()
         {
             TestUtils.AreEqual(new double4(0.0), math.square(new double4(0.0)));
@@ -3584,7 +3584,7 @@ public static void square_double4()
             TestUtils.AreEqual(new double4(0.272176139782814630053, 96307.5985667444765568 /*96307.5985667444765568*/, 5591.63402314303675666 /*5591.6337890625*/, 152764.275950208306313 /*152764.28125*/), math.square(new double4(0.521705031394958496094, -310.33465576171875, -74.77722930908203125, 390.8507080078125)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void square_int()
         {
             TestUtils.AreEqual(0, math.square(0));
@@ -3612,7 +3612,7 @@ public static void square_int()
             TestUtils.AreEqual(0, math.square(-2147483648));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void square_int2()
         {
             TestUtils.AreEqual(new int2(0), math.square(new int2(0)));
@@ -3643,7 +3643,7 @@ public static void square_int2()
             TestUtils.AreEqual(new int2(2121580241, -685235535), math.square(new int2(-831443639, 1415191751)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void square_int3()
         {
             TestUtils.AreEqual(new int3(0), math.square(new int3(0)));
@@ -3674,7 +3674,7 @@ public static void square_int3()
             TestUtils.AreEqual(new int3(2121580241, -685235535, 468048505), math.square(new int3(-831443639, 1415191751, -178100469)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void square_int4()
         {
             TestUtils.AreEqual(new int4(0), math.square(new int4(0)));
@@ -3705,7 +3705,7 @@ public static void square_int4()
             TestUtils.AreEqual(new int4(2121580241, -685235535, 468048505, -1902728316), math.square(new int4(-831443639, 1415191751, -178100469, 1331775970)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void square_uint()
         {
             TestUtils.AreEqual(0u, math.square(0u));
@@ -3723,7 +3723,7 @@ public static void square_uint()
             TestUtils.AreEqual(2356482048u, math.square(123456u));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void square_uint2()
         {
             TestUtils.AreEqual(new uint2(0u), math.square(new uint2(0u)));
@@ -3744,7 +3744,7 @@ public static void square_uint2()
             TestUtils.AreEqual(new uint2(3982663844u, 503153673u), math.square(new uint2(779359642u, 2488899075u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void square_uint3()
         {
             TestUtils.AreEqual(new uint3(0u), math.square(new uint3(0u)));
@@ -3765,7 +3765,7 @@ public static void square_uint3()
             TestUtils.AreEqual(new uint3(3982663844u, 503153673u, 4101817232u), math.square(new uint3(779359642u, 2488899075u, 407772844u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void square_uint4()
         {
             TestUtils.AreEqual(new uint4(0u), math.square(new uint4(0u)));
@@ -3809,7 +3809,7 @@ static double OrthonormalBasisSquaredError(double3 v1, double3 v2, double3 v3)
         // "Building an Orthonormal Basis, Revisited" table 1.
         private const double kOrthonormalBasisSqErrorTolerance = 1.04e-7d;
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void orthonormal_basis_float()
         {
             var random = new Random(8189782u);
@@ -3824,7 +3824,7 @@ public static void orthonormal_basis_float()
             }
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void orthonormal_basis_double()
         {
             var random = new Random(99917872u);
@@ -3839,7 +3839,7 @@ public static void orthonormal_basis_double()
             }
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void chgsign_float()
         {
             float c = chgsign(1f, -1f);
@@ -3901,7 +3901,7 @@ public static void chgsign_float()
             TestUtils.AreEqual(asuint(TestUtils.SignedFloatZero()), asuint(c));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void chgsign_float2()
         {
             float2 c = chgsign(float2(1f, -2f), float2(-1f, 23.548f));
@@ -3936,7 +3936,7 @@ public static void chgsign_float2()
             TestUtils.AreEqual(asuint(math.float2(TestUtils.SignedFloatZero())), asuint(c));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void chgsign_float3()
         {
             float3 c = chgsign(float3(1f, -2f, 3f), float3(-1f, 23.548f, -0f));
@@ -3971,7 +3971,7 @@ public static void chgsign_float3()
             TestUtils.AreEqual(asuint(math.float3(TestUtils.SignedFloatZero())), asuint(c));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void chgsign_float4()
         {
             float4 c = chgsign(float4(1f, 2f, 3f, -4f), float4(-1f, 0f, -0f, -23.56f));
@@ -4006,7 +4006,7 @@ public static void chgsign_float4()
             TestUtils.AreEqual(asuint(math.float4(TestUtils.SignedFloatZero())), asuint(c));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static unsafe void quaternion_to_euler()
         {
             const float epsilon = 0.0045f;
@@ -4079,7 +4079,7 @@ static quaternion TestRefEulerToQuat(float3 angle, math.RotationOrder order)
             }
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mulScale()
         {
             var tolerance = 1e-5f;
@@ -4101,7 +4101,7 @@ public static void mulScale()
             TestUtils.AreEqual(expected, actual, tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void scaleMul()
         {
             var tolerance = 1e-5f;
@@ -4123,7 +4123,7 @@ public static void scaleMul()
             TestUtils.AreEqual(expected, actual, tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void piDoubleConstants()
         {
             var expectedPi = 3.141592653589793116;
@@ -4133,7 +4133,7 @@ public static void piDoubleConstants()
             TestUtils.AreEqual(expectedPi * 2.0, TAU_DBL);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void piSingleConstants()
         {
             var expectedPi = 3.141592653589793116f;
@@ -4143,7 +4143,7 @@ public static void piSingleConstants()
             TestUtils.AreEqual(expectedPi * 2.0f, TAU);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void toDegreesConstants()
         {
             TestUtils.AreEqual(360.0, PI2_DBL * TODEGREES_DBL);
@@ -4157,7 +4157,7 @@ public static void toDegreesConstants()
             TestUtils.AreEqual(90.0f, PIHALF * TODEGREES);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void toRadiansConstants()
         {
             TestUtils.AreEqual(PI2_DBL, 360.0 * TORADIANS_DBL);
@@ -4171,7 +4171,7 @@ public static void toRadiansConstants()
             TestUtils.AreEqual(PIHALF, 90.0f * TORADIANS);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void degreesConversionGivesSameResult()
         {
             int n = 360;
@@ -4184,7 +4184,7 @@ public static void degreesConversionGivesSameResult()
             }
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void radiansConversionGivesSameResult()
         {
             int n = 360;
diff --git a/src/Tests/Tests/Shared/TestMath.gen.cs b/src/Tests/Tests/Shared/TestMath.gen.cs
index 1a8e3253..3a803b97 100644
--- a/src/Tests/Tests/Shared/TestMath.gen.cs
+++ b/src/Tests/Tests/Shared/TestMath.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public partial class TestMath
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void abs_int()
         {
             TestUtils.AreEqual(0, abs(0));
@@ -25,7 +25,7 @@ public static void abs_int()
             TestUtils.AreEqual(-2147483648, abs(-2147483648));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void abs_int2()
         {
             TestUtils.AreEqual(int2(0, 7), abs(int2(0, -7)));
@@ -33,21 +33,21 @@ public static void abs_int2()
             TestUtils.AreEqual(int2(-2147483648, -2147483648), abs(int2(-2147483648, -2147483648)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void abs_int3()
         {
             TestUtils.AreEqual(int3(0, 7, 11), abs(int3(0, -7, 11)));
             TestUtils.AreEqual(int3(2147483647, -2147483648, -2147483648), abs(int3(-2147483647, -2147483648, -2147483648)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void abs_int4()
         {
             TestUtils.AreEqual(int4(0, 7, 11, 2147483647), abs(int4(0, -7, 11, -2147483647)));
             TestUtils.AreEqual(int4(-2147483648, -2147483648, -2147483648, -2147483648), abs(int4(-2147483648, -2147483648, -2147483648, -2147483648)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void abs_float()
         {
             TestUtils.AreEqual(0f, abs(0f));
@@ -57,7 +57,7 @@ public static void abs_float()
             TestUtils.AreEqual(float.PositiveInfinity, abs(float.PositiveInfinity));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void abs_float2()
         {
             TestUtils.AreEqual(float2(0f, 1.1f), abs(float2(0f, -1.1f)));
@@ -65,21 +65,21 @@ public static void abs_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), abs(float2(float.PositiveInfinity, float.PositiveInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void abs_float3()
         {
             TestUtils.AreEqual(float3(0f, 1.1f, 2.2f), abs(float3(0f, -1.1f, 2.2f)));
             TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), abs(float3(float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void abs_float4()
         {
             TestUtils.AreEqual(float4(0f, 1.1f, 2.2f, float.PositiveInfinity), abs(float4(0f, -1.1f, 2.2f, float.NegativeInfinity)));
             TestUtils.AreEqual(float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), abs(float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void abs_double()
         {
             TestUtils.AreEqual(0.0, abs(0.0));
@@ -89,7 +89,7 @@ public static void abs_double()
             TestUtils.AreEqual(double.PositiveInfinity, abs(double.PositiveInfinity));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void abs_double2()
         {
             TestUtils.AreEqual(double2(0.0, 1.1), abs(double2(0.0, -1.1)));
@@ -97,21 +97,21 @@ public static void abs_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), abs(double2(double.PositiveInfinity, double.PositiveInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void abs_double3()
         {
             TestUtils.AreEqual(double3(0.0, 1.1, 2.2), abs(double3(0.0, -1.1, 2.2)));
             TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), abs(double3(double.NegativeInfinity, double.PositiveInfinity, double.PositiveInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void abs_double4()
         {
             TestUtils.AreEqual(double4(0.0, 1.1, 2.2, double.PositiveInfinity), abs(double4(0.0, -1.1, 2.2, double.NegativeInfinity)));
             TestUtils.AreEqual(double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), abs(double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isfinite_float()
         {
             TestUtils.AreEqual(false, isfinite(TestUtils.SignedFloatQNaN()));
@@ -125,7 +125,7 @@ public static void isfinite_float()
             TestUtils.AreEqual(false, isfinite(TestUtils.UnsignedFloatQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isfinite_float2()
         {
             TestUtils.AreEqual(bool2(false, false), isfinite(float2(TestUtils.SignedFloatQNaN(), float.NegativeInfinity)));
@@ -135,7 +135,7 @@ public static void isfinite_float2()
             TestUtils.AreEqual(bool2(false, false), isfinite(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isfinite_float3()
         {
             TestUtils.AreEqual(bool3(false, false, true), isfinite(float3(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue)));
@@ -143,7 +143,7 @@ public static void isfinite_float3()
             TestUtils.AreEqual(bool3(true, false, false), isfinite(float3(float.MaxValue, float.PositiveInfinity, TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isfinite_float4()
         {
             TestUtils.AreEqual(bool4(false, false, true, true), isfinite(float4(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue, -1f)));
@@ -151,7 +151,7 @@ public static void isfinite_float4()
             TestUtils.AreEqual(bool4(false, false, false, false), isfinite(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isfinite_double()
         {
             TestUtils.AreEqual(false, isfinite(TestUtils.SignedDoubleQNaN()));
@@ -165,7 +165,7 @@ public static void isfinite_double()
             TestUtils.AreEqual(false, isfinite(TestUtils.UnsignedDoubleQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isfinite_double2()
         {
             TestUtils.AreEqual(bool2(false, false), isfinite(double2(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity)));
@@ -175,7 +175,7 @@ public static void isfinite_double2()
             TestUtils.AreEqual(bool2(false, false), isfinite(double2(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isfinite_double3()
         {
             TestUtils.AreEqual(bool3(false, false, true), isfinite(double3(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue)));
@@ -183,7 +183,7 @@ public static void isfinite_double3()
             TestUtils.AreEqual(bool3(true, false, false), isfinite(double3(double.MaxValue, double.PositiveInfinity, TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isfinite_double4()
         {
             TestUtils.AreEqual(bool4(false, false, true, true), isfinite(double4(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue, -1.0)));
@@ -191,7 +191,7 @@ public static void isfinite_double4()
             TestUtils.AreEqual(bool4(false, false, false, false), isfinite(double4(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isinf_float()
         {
             TestUtils.AreEqual(false, isinf(TestUtils.SignedFloatQNaN()));
@@ -205,7 +205,7 @@ public static void isinf_float()
             TestUtils.AreEqual(false, isinf(TestUtils.UnsignedFloatQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isinf_float2()
         {
             TestUtils.AreEqual(bool2(false, true), isinf(float2(TestUtils.SignedFloatQNaN(), float.NegativeInfinity)));
@@ -215,7 +215,7 @@ public static void isinf_float2()
             TestUtils.AreEqual(bool2(false, false), isinf(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isinf_float3()
         {
             TestUtils.AreEqual(bool3(false, true, false), isinf(float3(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue)));
@@ -223,7 +223,7 @@ public static void isinf_float3()
             TestUtils.AreEqual(bool3(false, true, false), isinf(float3(float.MaxValue, float.PositiveInfinity, TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isinf_float4()
         {
             TestUtils.AreEqual(bool4(false, true, false, false), isinf(float4(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue, -1f)));
@@ -231,7 +231,7 @@ public static void isinf_float4()
             TestUtils.AreEqual(bool4(false, false, false, false), isinf(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isinf_double()
         {
             TestUtils.AreEqual(false, isinf(TestUtils.SignedDoubleQNaN()));
@@ -245,7 +245,7 @@ public static void isinf_double()
             TestUtils.AreEqual(false, isinf(TestUtils.UnsignedDoubleQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isinf_double2()
         {
             TestUtils.AreEqual(bool2(false, true), isinf(double2(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity)));
@@ -255,7 +255,7 @@ public static void isinf_double2()
             TestUtils.AreEqual(bool2(false, false), isinf(double2(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isinf_double3()
         {
             TestUtils.AreEqual(bool3(false, true, false), isinf(double3(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue)));
@@ -263,7 +263,7 @@ public static void isinf_double3()
             TestUtils.AreEqual(bool3(false, true, false), isinf(double3(double.MaxValue, double.PositiveInfinity, TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isinf_double4()
         {
             TestUtils.AreEqual(bool4(false, true, false, false), isinf(double4(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue, -1.0)));
@@ -271,7 +271,7 @@ public static void isinf_double4()
             TestUtils.AreEqual(bool4(false, false, false, false), isinf(double4(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isnan_float()
         {
             TestUtils.AreEqual(true, isnan(TestUtils.SignedFloatQNaN()));
@@ -285,7 +285,7 @@ public static void isnan_float()
             TestUtils.AreEqual(true, isnan(TestUtils.UnsignedFloatQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isnan_float2()
         {
             TestUtils.AreEqual(bool2(true, false), isnan(float2(TestUtils.SignedFloatQNaN(), float.NegativeInfinity)));
@@ -295,7 +295,7 @@ public static void isnan_float2()
             TestUtils.AreEqual(bool2(true, true), isnan(float2(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isnan_float3()
         {
             TestUtils.AreEqual(bool3(true, false, false), isnan(float3(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue)));
@@ -303,7 +303,7 @@ public static void isnan_float3()
             TestUtils.AreEqual(bool3(false, false, true), isnan(float3(float.MaxValue, float.PositiveInfinity, TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isnan_float4()
         {
             TestUtils.AreEqual(bool4(true, false, false, false), isnan(float4(TestUtils.SignedFloatQNaN(), float.NegativeInfinity, float.MinValue, -1f)));
@@ -311,7 +311,7 @@ public static void isnan_float4()
             TestUtils.AreEqual(bool4(true, true, true, true), isnan(float4(TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN(), TestUtils.UnsignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isnan_double()
         {
             TestUtils.AreEqual(true, isnan(TestUtils.SignedDoubleQNaN()));
@@ -325,7 +325,7 @@ public static void isnan_double()
             TestUtils.AreEqual(true, isnan(TestUtils.UnsignedDoubleQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isnan_double2()
         {
             TestUtils.AreEqual(bool2(true, false), isnan(double2(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity)));
@@ -335,7 +335,7 @@ public static void isnan_double2()
             TestUtils.AreEqual(bool2(true, true), isnan(double2(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isnan_double3()
         {
             TestUtils.AreEqual(bool3(true, false, false), isnan(double3(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue)));
@@ -343,7 +343,7 @@ public static void isnan_double3()
             TestUtils.AreEqual(bool3(false, false, true), isnan(double3(double.MaxValue, double.PositiveInfinity, TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void isnan_double4()
         {
             TestUtils.AreEqual(bool4(true, false, false, false), isnan(double4(TestUtils.SignedDoubleQNaN(), double.NegativeInfinity, double.MinValue, -1.0)));
@@ -351,7 +351,7 @@ public static void isnan_double4()
             TestUtils.AreEqual(bool4(true, true, true, true), isnan(double4(TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN(), TestUtils.UnsignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sin_float()
         {
             TestUtils.AreEqual(0.3499935f, sin(-1000000f), 1, false);
@@ -364,7 +364,7 @@ public static void sin_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), sin(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sin_float2()
         {
             TestUtils.AreEqual(float2(0.3499935f, -0.9320391f), sin(float2(-1000000f, -1.2f)), 1, false);
@@ -373,7 +373,7 @@ public static void sin_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), sin(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sin_float3()
         {
             TestUtils.AreEqual(float3(0.3499935f, -0.9320391f, 0f), sin(float3(-1000000f, -1.2f, 0f)), 1, false);
@@ -381,14 +381,14 @@ public static void sin_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), sin(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sin_float4()
         {
             TestUtils.AreEqual(float4(0.3499935f, -0.9320391f, 0f, 0.9320391f), sin(float4(-1000000f, -1.2f, 0f, 1.2f)), 1, false);
             TestUtils.AreEqual(float4(-0.3499935f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), sin(float4(1000000f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sin_double()
         {
             TestUtils.AreEqual(0.34999350217129294, sin(-1000000.0), 32, false);
@@ -401,7 +401,7 @@ public static void sin_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), sin(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sin_double2()
         {
             TestUtils.AreEqual(double2(0.34999350217129294, -0.9320390859672264), sin(double2(-1000000.0, -1.2)), 32, false);
@@ -410,7 +410,7 @@ public static void sin_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), sin(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sin_double3()
         {
             TestUtils.AreEqual(double3(0.34999350217129294, -0.9320390859672264, 0.0), sin(double3(-1000000.0, -1.2, 0.0)), 32, false);
@@ -418,14 +418,14 @@ public static void sin_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), sin(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sin_double4()
         {
             TestUtils.AreEqual(double4(0.34999350217129294, -0.9320390859672264, 0.0, 0.9320390859672264), sin(double4(-1000000.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(-0.34999350217129294, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), sin(double4(1000000.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cos_float()
         {
             TestUtils.AreEqual(0.936752141f, cos(-1000000f), 8, false);
@@ -438,7 +438,7 @@ public static void cos_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), cos(float.PositiveInfinity), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cos_float2()
         {
             TestUtils.AreEqual(float2(0.936752141f, 0.362357765f), cos(float2(-1000000f, -1.2f)), 8, false);
@@ -447,7 +447,7 @@ public static void cos_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), cos(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cos_float3()
         {
             TestUtils.AreEqual(float3(0.936752141f, 0.362357765f, 1f), cos(float3(-1000000f, -1.2f, 0f)), 8, false);
@@ -455,14 +455,14 @@ public static void cos_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), cos(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cos_float4()
         {
             TestUtils.AreEqual(float4(0.936752141f, 0.362357765f, 1f, 0.362357765f), cos(float4(-1000000f, -1.2f, 0f, 1.2f)), 8, false);
             TestUtils.AreEqual(float4(0.936752141f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), cos(float4(1000000f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cos_double()
         {
             TestUtils.AreEqual(0.93675212753314474, cos(-1000000.0), 32, false);
@@ -475,7 +475,7 @@ public static void cos_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), cos(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cos_double2()
         {
             TestUtils.AreEqual(double2(0.93675212753314474, 0.36235775447667357), cos(double2(-1000000.0, -1.2)), 32, false);
@@ -484,7 +484,7 @@ public static void cos_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), cos(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cos_double3()
         {
             TestUtils.AreEqual(double3(0.93675212753314474, 0.36235775447667357, 1.0), cos(double3(-1000000.0, -1.2, 0.0)), 32, false);
@@ -492,14 +492,14 @@ public static void cos_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), cos(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cos_double4()
         {
             TestUtils.AreEqual(double4(0.93675212753314474, 0.36235775447667357, 1.0, 0.36235775447667357), cos(double4(-1000000.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(0.93675212753314474, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), cos(double4(1000000.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tan_float()
         {
             TestUtils.AreEqual(0.373624444f, tan(-1000000f), 1, false);
@@ -512,7 +512,7 @@ public static void tan_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), tan(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tan_float2()
         {
             TestUtils.AreEqual(float2(0.373624444f, -2.57215166f), tan(float2(-1000000f, -1.2f)), 1, false);
@@ -521,7 +521,7 @@ public static void tan_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), tan(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tan_float3()
         {
             TestUtils.AreEqual(float3(0.373624444f, -2.57215166f, 0f), tan(float3(-1000000f, -1.2f, 0f)), 1, false);
@@ -529,14 +529,14 @@ public static void tan_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), tan(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tan_float4()
         {
             TestUtils.AreEqual(float4(0.373624444f, -2.57215166f, 0f, 2.57215166f), tan(float4(-1000000f, -1.2f, 0f, 1.2f)), 1, false);
             TestUtils.AreEqual(float4(-0.373624444f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), tan(float4(1000000f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tan_double()
         {
             TestUtils.AreEqual(0.373624453987599, tan(-1000000.0), 32, false);
@@ -549,7 +549,7 @@ public static void tan_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), tan(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tan_double2()
         {
             TestUtils.AreEqual(double2(0.373624453987599, -2.57215162212632), tan(double2(-1000000.0, -1.2)), 32, false);
@@ -558,7 +558,7 @@ public static void tan_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), tan(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tan_double3()
         {
             TestUtils.AreEqual(double3(0.373624453987599, -2.57215162212632, 0.0), tan(double3(-1000000.0, -1.2, 0.0)), 32, false);
@@ -566,14 +566,14 @@ public static void tan_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), tan(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tan_double4()
         {
             TestUtils.AreEqual(double4(0.373624453987599, -2.57215162212632, 0.0, 2.57215162212632), tan(double4(-1000000.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(-0.373624453987599, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), tan(double4(1000000.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void atan_float()
         {
             TestUtils.AreEqual(-1.5707953f, atan(-1000000f), 1, false);
@@ -586,7 +586,7 @@ public static void atan_float()
             TestUtils.AreEqual(1.57079637f, atan(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void atan_float2()
         {
             TestUtils.AreEqual(float2(-1.5707953f, -0.876058042f), atan(float2(-1000000f, -1.2f)), 1, false);
@@ -595,7 +595,7 @@ public static void atan_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), 1.57079637f), atan(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void atan_float3()
         {
             TestUtils.AreEqual(float3(-1.5707953f, -0.876058042f, 0f), atan(float3(-1000000f, -1.2f, 0f)), 1, false);
@@ -603,14 +603,14 @@ public static void atan_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 1.57079637f, 1.57079637f), atan(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void atan_float4()
         {
             TestUtils.AreEqual(float4(-1.5707953f, -0.876058042f, 0f, 0.876058042f), atan(float4(-1000000f, -1.2f, 0f, 1.2f)), 1, false);
             TestUtils.AreEqual(float4(1.5707953f, -1.57079637f, TestUtils.SignedFloatQNaN(), 1.57079637f), atan(float4(1000000f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void atan_double()
         {
             TestUtils.AreEqual(-1.5707953267948971, atan(-1000000.0), 32, false);
@@ -623,7 +623,7 @@ public static void atan_double()
             TestUtils.AreEqual(1.570796326794897, atan(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void atan_double2()
         {
             TestUtils.AreEqual(double2(-1.5707953267948971, -0.87605805059819342), atan(double2(-1000000.0, -1.2)), 32, false);
@@ -632,7 +632,7 @@ public static void atan_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), 1.570796326794897), atan(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void atan_double3()
         {
             TestUtils.AreEqual(double3(-1.5707953267948971, -0.87605805059819342, 0.0), atan(double3(-1000000.0, -1.2, 0.0)), 32, false);
@@ -640,14 +640,14 @@ public static void atan_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 1.570796326794897, 1.570796326794897), atan(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void atan_double4()
         {
             TestUtils.AreEqual(double4(-1.5707953267948971, -0.87605805059819342, 0.0, 0.87605805059819342), atan(double4(-1000000.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(1.5707953267948971, -1.570796326794897, TestUtils.SignedDoubleQNaN(), 1.570796326794897), atan(double4(1000000.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void atan2_float()
         {
             TestUtils.AreEqual(0.9119903f, atan2(3.1f, 2.4f), 1, false);
@@ -664,7 +664,7 @@ public static void atan2_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), atan2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void atan2_float2()
         {
             TestUtils.AreEqual(float2(0.9119903f, 2.22960234f), atan2(float2(3.1f, 3.1f), float2(2.4f, -2.4f)), 1, false);
@@ -675,7 +675,7 @@ public static void atan2_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), atan2(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(1f, TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void atan2_float3()
         {
             TestUtils.AreEqual(float3(0.9119903f, 2.22960234f, -0.9119903f), atan2(float3(3.1f, 3.1f, -3.1f), float3(2.4f, -2.4f, 2.4f)), 1, false);
@@ -684,7 +684,7 @@ public static void atan2_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), atan2(float3(1f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), 1f, TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void atan2_float4()
         {
             TestUtils.AreEqual(float4(0.9119903f, 2.22960234f, -0.9119903f, -2.22960234f), atan2(float4(3.1f, 3.1f, -3.1f, -3.1f), float4(2.4f, -2.4f, 2.4f, -2.4f)), 1, false);
@@ -692,7 +692,7 @@ public static void atan2_float4()
             TestUtils.AreEqual(float4(1.57079637f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), atan2(float4(float.PositiveInfinity, 1f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(1f, TestUtils.SignedFloatQNaN(), 1f, TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void atan2_double()
         {
             TestUtils.AreEqual(0.91199029067742043, atan2(3.1, 2.4), 32, false);
@@ -709,7 +709,7 @@ public static void atan2_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), atan2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void atan2_double2()
         {
             TestUtils.AreEqual(double2(0.91199029067742043, 2.2296023629123729), atan2(double2(3.1, 3.1), double2(2.4, -2.4)), 32, false);
@@ -720,7 +720,7 @@ public static void atan2_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), atan2(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(1.0, TestUtils.SignedDoubleQNaN())), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void atan2_double3()
         {
             TestUtils.AreEqual(double3(0.91199029067742043, 2.2296023629123729, -0.91199029067742043), atan2(double3(3.1, 3.1, -3.1), double3(2.4, -2.4, 2.4)), 32, false);
@@ -729,7 +729,7 @@ public static void atan2_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), atan2(double3(1.0, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), 1.0, TestUtils.SignedDoubleQNaN())), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void atan2_double4()
         {
             TestUtils.AreEqual(double4(0.91199029067742043, 2.2296023629123729, -0.91199029067742043, -2.2296023629123729), atan2(double4(3.1, 3.1, -3.1, -3.1), double4(2.4, -2.4, 2.4, -2.4)), 32, false);
@@ -737,7 +737,7 @@ public static void atan2_double4()
             TestUtils.AreEqual(double4(1.5707963267948966, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), atan2(double4(double.PositiveInfinity, 1.0, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(1.0, TestUtils.SignedDoubleQNaN(), 1.0, TestUtils.SignedDoubleQNaN())), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sinh_float()
         {
             TestUtils.AreEqual(-3.62686038f, sinh(-2f), 1, false);
@@ -750,7 +750,7 @@ public static void sinh_float()
             TestUtils.AreEqual(float.PositiveInfinity, sinh(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sinh_float2()
         {
             TestUtils.AreEqual(float2(-3.62686038f, -1.5094614f), sinh(float2(-2f, -1.2f)), 1, false);
@@ -759,7 +759,7 @@ public static void sinh_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), sinh(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sinh_float3()
         {
             TestUtils.AreEqual(float3(-3.62686038f, -1.5094614f, 0f), sinh(float3(-2f, -1.2f, 0f)), 1, false);
@@ -767,14 +767,14 @@ public static void sinh_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), sinh(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sinh_float4()
         {
             TestUtils.AreEqual(float4(-3.62686038f, -1.5094614f, 0f, 1.5094614f), sinh(float4(-2f, -1.2f, 0f, 1.2f)), 1, false);
             TestUtils.AreEqual(float4(3.62686038f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity), sinh(float4(2f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sinh_double()
         {
             TestUtils.AreEqual(-3.6268604078470181, sinh(-2.0), 32, false);
@@ -787,7 +787,7 @@ public static void sinh_double()
             TestUtils.AreEqual(double.PositiveInfinity, sinh(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sinh_double2()
         {
             TestUtils.AreEqual(double2(-3.6268604078470181, -1.509461355412173), sinh(double2(-2.0, -1.2)), 32, false);
@@ -796,7 +796,7 @@ public static void sinh_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), sinh(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sinh_double3()
         {
             TestUtils.AreEqual(double3(-3.6268604078470181, -1.509461355412173, 0.0), sinh(double3(-2.0, -1.2, 0.0)), 32, false);
@@ -804,14 +804,14 @@ public static void sinh_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), sinh(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sinh_double4()
         {
             TestUtils.AreEqual(double4(-3.6268604078470181, -1.509461355412173, 0.0, 1.509461355412173), sinh(double4(-2.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(3.6268604078470181, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), sinh(double4(2.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cosh_float()
         {
             TestUtils.AreEqual(3.76219559f, cosh(-2f), 1, false);
@@ -824,7 +824,7 @@ public static void cosh_float()
             TestUtils.AreEqual(float.PositiveInfinity, cosh(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cosh_float2()
         {
             TestUtils.AreEqual(float2(3.76219559f, 1.81065559f), cosh(float2(-2f, -1.2f)), 1, false);
@@ -833,7 +833,7 @@ public static void cosh_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), cosh(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cosh_float3()
         {
             TestUtils.AreEqual(float3(3.76219559f, 1.81065559f, 1f), cosh(float3(-2f, -1.2f, 0f)), 1, false);
@@ -841,14 +841,14 @@ public static void cosh_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), cosh(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cosh_float4()
         {
             TestUtils.AreEqual(float4(3.76219559f, 1.81065559f, 1f, 1.81065559f), cosh(float4(-2f, -1.2f, 0f, 1.2f)), 1, false);
             TestUtils.AreEqual(float4(3.76219559f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity), cosh(float4(2f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cosh_double()
         {
             TestUtils.AreEqual(3.7621956910836314, cosh(-2.0), 32, false);
@@ -861,7 +861,7 @@ public static void cosh_double()
             TestUtils.AreEqual(double.PositiveInfinity, cosh(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cosh_double2()
         {
             TestUtils.AreEqual(double2(3.7621956910836314, 1.81065556732437), cosh(double2(-2.0, -1.2)), 32, false);
@@ -870,7 +870,7 @@ public static void cosh_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), cosh(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cosh_double3()
         {
             TestUtils.AreEqual(double3(3.7621956910836314, 1.81065556732437, 1.0), cosh(double3(-2.0, -1.2, 0.0)), 32, false);
@@ -878,14 +878,14 @@ public static void cosh_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), cosh(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void cosh_double4()
         {
             TestUtils.AreEqual(double4(3.7621956910836314, 1.81065556732437, 1.0, 1.81065556732437), cosh(double4(-2.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(3.7621956910836314, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), cosh(double4(2.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tanh_float()
         {
             TestUtils.AreEqual(-0.9640276f, tanh(-2f), 1, false);
@@ -898,7 +898,7 @@ public static void tanh_float()
             TestUtils.AreEqual(1f, tanh(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tanh_float2()
         {
             TestUtils.AreEqual(float2(-0.9640276f, -0.8336546f), tanh(float2(-2f, -1.2f)), 1, false);
@@ -907,7 +907,7 @@ public static void tanh_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), 1f), tanh(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tanh_float3()
         {
             TestUtils.AreEqual(float3(-0.9640276f, -0.8336546f, 0f), tanh(float3(-2f, -1.2f, 0f)), 1, false);
@@ -915,14 +915,14 @@ public static void tanh_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 1f, 1f), tanh(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tanh_float4()
         {
             TestUtils.AreEqual(float4(-0.9640276f, -0.8336546f, 0f, 0.8336546f), tanh(float4(-2f, -1.2f, 0f, 1.2f)), 1, false);
             TestUtils.AreEqual(float4(0.9640276f, -1f, TestUtils.SignedFloatQNaN(), 1f), tanh(float4(2f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tanh_double()
         {
             TestUtils.AreEqual(-0.9640275800758169, tanh(-2.0), 32, false);
@@ -935,7 +935,7 @@ public static void tanh_double()
             TestUtils.AreEqual(1.0, tanh(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tanh_double2()
         {
             TestUtils.AreEqual(double2(-0.9640275800758169, -0.83365460701215521), tanh(double2(-2.0, -1.2)), 32, false);
@@ -944,7 +944,7 @@ public static void tanh_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), 1.0), tanh(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tanh_double3()
         {
             TestUtils.AreEqual(double3(-0.9640275800758169, -0.83365460701215521, 0.0), tanh(double3(-2.0, -1.2, 0.0)), 32, false);
@@ -952,14 +952,14 @@ public static void tanh_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 1.0, 1.0), tanh(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void tanh_double4()
         {
             TestUtils.AreEqual(double4(-0.9640275800758169, -0.83365460701215521, 0.0, 0.83365460701215521), tanh(double4(-2.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(0.9640275800758169, -1.0, TestUtils.SignedDoubleQNaN(), 1.0), tanh(double4(2.0, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp_float()
         {
             TestUtils.AreEqual(4.539993E-05f, exp(-10f), 1, false);
@@ -971,7 +971,7 @@ public static void exp_float()
             TestUtils.AreEqual(float.PositiveInfinity, exp(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp_float2()
         {
             TestUtils.AreEqual(float2(4.539993E-05f, 0.301194221f), exp(float2(-10f, -1.2f)), 1, false);
@@ -980,7 +980,7 @@ public static void exp_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), exp(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp_float3()
         {
             TestUtils.AreEqual(float3(4.539993E-05f, 0.301194221f, 1f), exp(float3(-10f, -1.2f, 0f)), 1, false);
@@ -988,14 +988,14 @@ public static void exp_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), exp(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp_float4()
         {
             TestUtils.AreEqual(float4(4.539993E-05f, 0.301194221f, 1f, 3.320117f), exp(float4(-10f, -1.2f, 0f, 1.2f)), 1, false);
             TestUtils.AreEqual(float4(0f, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), exp(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp_double()
         {
             TestUtils.AreEqual(4.5399929762484847E-05, exp(-10.0), 32, false);
@@ -1007,7 +1007,7 @@ public static void exp_double()
             TestUtils.AreEqual(double.PositiveInfinity, exp(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp_double2()
         {
             TestUtils.AreEqual(double2(4.5399929762484847E-05, 0.30119421191220208), exp(double2(-10.0, -1.2)), 32, false);
@@ -1016,7 +1016,7 @@ public static void exp_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), exp(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp_double3()
         {
             TestUtils.AreEqual(double3(4.5399929762484847E-05, 0.30119421191220208, 1.0), exp(double3(-10.0, -1.2, 0.0)), 32, false);
@@ -1024,14 +1024,14 @@ public static void exp_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), exp(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp_double4()
         {
             TestUtils.AreEqual(double4(4.5399929762484847E-05, 0.30119421191220208, 1.0, 3.3201169227365477), exp(double4(-10.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(0.0, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), exp(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp2_float()
         {
             TestUtils.AreEqual(0.0009765625f, exp2(-10f), 1, false);
@@ -1043,7 +1043,7 @@ public static void exp2_float()
             TestUtils.AreEqual(float.PositiveInfinity, exp2(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp2_float2()
         {
             TestUtils.AreEqual(float2(0.0009765625f, 0.4352753f), exp2(float2(-10f, -1.2f)), 1, false);
@@ -1052,7 +1052,7 @@ public static void exp2_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), exp2(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp2_float3()
         {
             TestUtils.AreEqual(float3(0.0009765625f, 0.4352753f, 1f), exp2(float3(-10f, -1.2f, 0f)), 1, false);
@@ -1060,14 +1060,14 @@ public static void exp2_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), exp2(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp2_float4()
         {
             TestUtils.AreEqual(float4(0.0009765625f, 0.4352753f, 1f, 2.29739666f), exp2(float4(-10f, -1.2f, 0f, 1.2f)), 1, false);
             TestUtils.AreEqual(float4(0f, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), exp2(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp2_double()
         {
             TestUtils.AreEqual(0.0009765625, exp2(-10.0), 32, false);
@@ -1079,7 +1079,7 @@ public static void exp2_double()
             TestUtils.AreEqual(double.PositiveInfinity, exp2(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp2_double2()
         {
             TestUtils.AreEqual(double2(0.0009765625, 0.435275281648062), exp2(double2(-10.0, -1.2)), 32, false);
@@ -1088,7 +1088,7 @@ public static void exp2_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), exp2(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp2_double3()
         {
             TestUtils.AreEqual(double3(0.0009765625, 0.435275281648062, 1.0), exp2(double3(-10.0, -1.2, 0.0)), 32, false);
@@ -1096,14 +1096,14 @@ public static void exp2_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), exp2(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp2_double4()
         {
             TestUtils.AreEqual(double4(0.0009765625, 0.435275281648062, 1.0, 2.29739670999407), exp2(double4(-10.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(0.0, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), exp2(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp10_float()
         {
             TestUtils.AreEqual(1E-10f, exp10(-10f), 32, false);
@@ -1115,7 +1115,7 @@ public static void exp10_float()
             TestUtils.AreEqual(float.PositiveInfinity, exp10(float.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp10_float2()
         {
             TestUtils.AreEqual(float2(1E-10f, 0.06309573f), exp10(float2(-10f, -1.2f)), 32, false);
@@ -1124,7 +1124,7 @@ public static void exp10_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), exp10(float2(float.PositiveInfinity, float.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp10_float3()
         {
             TestUtils.AreEqual(float3(1E-10f, 0.06309573f, 1f), exp10(float3(-10f, -1.2f, 0f)), 32, false);
@@ -1132,14 +1132,14 @@ public static void exp10_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), exp10(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp10_float4()
         {
             TestUtils.AreEqual(float4(1E-10f, 0.06309573f, 1f, 15.8489323f), exp10(float4(-10f, -1.2f, 0f, 1.2f)), 32, false);
             TestUtils.AreEqual(float4(0f, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), exp10(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp10_double()
         {
             TestUtils.AreEqual(1E-10, exp10(-10.0), 32, false);
@@ -1151,7 +1151,7 @@ public static void exp10_double()
             TestUtils.AreEqual(double.PositiveInfinity, exp10(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp10_double2()
         {
             TestUtils.AreEqual(double2(1E-10, 0.063095734448019331), exp10(double2(-10.0, -1.2)), 32, false);
@@ -1160,7 +1160,7 @@ public static void exp10_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), exp10(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp10_double3()
         {
             TestUtils.AreEqual(double3(1E-10, 0.063095734448019331, 1.0), exp10(double3(-10.0, -1.2, 0.0)), 32, false);
@@ -1168,14 +1168,14 @@ public static void exp10_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), exp10(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void exp10_double4()
         {
             TestUtils.AreEqual(double4(1E-10, 0.063095734448019331, 1.0, 15.848931924611135), exp10(double4(-10.0, -1.2, 0.0, 1.2)), 32, false);
             TestUtils.AreEqual(double4(0.0, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), exp10(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log_float()
         {
             TestUtils.AreEqual(-20.5409451f, log(1.2E-09f), 1, false);
@@ -1187,7 +1187,7 @@ public static void log_float()
             TestUtils.AreEqual(float.PositiveInfinity, log(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log_float2()
         {
             TestUtils.AreEqual(float2(-20.5409451f, 0f), log(float2(1.2E-09f, 1f)), 1, false);
@@ -1196,7 +1196,7 @@ public static void log_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), log(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log_float3()
         {
             TestUtils.AreEqual(float3(-20.5409451f, 0f, 23.2081718f), log(float3(1.2E-09f, 1f, 1.2E+10f)), 1, false);
@@ -1204,14 +1204,14 @@ public static void log_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), log(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log_float4()
         {
             TestUtils.AreEqual(float4(-20.5409451f, 0f, 23.2081718f, TestUtils.SignedFloatQNaN()), log(float4(1.2E-09f, 1f, 1.2E+10f, -1f)), 1, false);
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), log(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log_double()
         {
             TestUtils.AreEqual(-20.540944280152456, log(1.2E-09), 32, false);
@@ -1223,7 +1223,7 @@ public static void log_double()
             TestUtils.AreEqual(double.PositiveInfinity, log(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log_double2()
         {
             TestUtils.AreEqual(double2(-20.540944280152456, 0.0), log(double2(1.2E-09, 1.0)), 32, false);
@@ -1232,7 +1232,7 @@ public static void log_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), log(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log_double3()
         {
             TestUtils.AreEqual(double3(-20.540944280152456, 0.0, 23.208172486734409), log(double3(1.2E-09, 1.0, 12000000000.0)), 32, false);
@@ -1240,14 +1240,14 @@ public static void log_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), log(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log_double4()
         {
             TestUtils.AreEqual(double4(-20.540944280152456, 0.0, 23.208172486734409, TestUtils.SignedDoubleQNaN()), log(double4(1.2E-09, 1.0, 12000000000.0, -1.0)), 32, false);
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), log(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log2_float()
         {
             TestUtils.AreEqual(-29.63432f, log2(1.2E-09f), 1, false);
@@ -1259,7 +1259,7 @@ public static void log2_float()
             TestUtils.AreEqual(float.PositiveInfinity, log2(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log2_float2()
         {
             TestUtils.AreEqual(float2(-29.63432f, 0f), log2(float2(1.2E-09f, 1f)), 1, false);
@@ -1268,7 +1268,7 @@ public static void log2_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), log2(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log2_float3()
         {
             TestUtils.AreEqual(float3(-29.63432f, 0f, 33.4823151f), log2(float3(1.2E-09f, 1f, 1.2E+10f)), 1, false);
@@ -1276,14 +1276,14 @@ public static void log2_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), log2(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log2_float4()
         {
             TestUtils.AreEqual(float4(-29.63432f, 0f, 33.4823151f, TestUtils.SignedFloatQNaN()), log2(float4(1.2E-09f, 1f, 1.2E+10f, -1f)), 1, false);
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), log2(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log2_double()
         {
             TestUtils.AreEqual(-29.634318448152467, log2(1.2E-09), 32, false);
@@ -1295,7 +1295,7 @@ public static void log2_double()
             TestUtils.AreEqual(double.PositiveInfinity, log2(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log2_double2()
         {
             TestUtils.AreEqual(double2(-29.634318448152467, 0.0), log2(double2(1.2E-09, 1.0)), 32, false);
@@ -1304,7 +1304,7 @@ public static void log2_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), log2(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log2_double3()
         {
             TestUtils.AreEqual(double3(-29.634318448152467, 0.0, 33.482315354707417), log2(double3(1.2E-09, 1.0, 12000000000.0)), 32, false);
@@ -1312,14 +1312,14 @@ public static void log2_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), log2(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log2_double4()
         {
             TestUtils.AreEqual(double4(-29.634318448152467, 0.0, 33.482315354707417, TestUtils.SignedDoubleQNaN()), log2(double4(1.2E-09, 1.0, 12000000000.0, -1.0)), 32, false);
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), log2(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log10_float()
         {
             TestUtils.AreEqual(-8.920818f, log10(1.2E-09f), 1, false);
@@ -1331,7 +1331,7 @@ public static void log10_float()
             TestUtils.AreEqual(float.PositiveInfinity, log10(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log10_float2()
         {
             TestUtils.AreEqual(float2(-8.920818f, 0f), log10(float2(1.2E-09f, 1f)), 1, false);
@@ -1340,7 +1340,7 @@ public static void log10_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), log10(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log10_float3()
         {
             TestUtils.AreEqual(float3(-8.920818f, 0f, 10.0791817f), log10(float3(1.2E-09f, 1f, 1.2E+10f)), 1, false);
@@ -1348,14 +1348,14 @@ public static void log10_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), log10(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log10_float4()
         {
             TestUtils.AreEqual(float4(-8.920818f, 0f, 10.0791817f, TestUtils.SignedFloatQNaN()), log10(float4(1.2E-09f, 1f, 1.2E+10f, -1f)), 1, false);
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), log10(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log10_double()
         {
             TestUtils.AreEqual(-8.9208187539523749, log10(1.2E-09), 32, false);
@@ -1367,7 +1367,7 @@ public static void log10_double()
             TestUtils.AreEqual(double.PositiveInfinity, log10(double.PositiveInfinity), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log10_double2()
         {
             TestUtils.AreEqual(double2(-8.9208187539523749, 0.0), log10(double2(1.2E-09, 1.0)), 32, false);
@@ -1376,7 +1376,7 @@ public static void log10_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), log10(double2(double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log10_double3()
         {
             TestUtils.AreEqual(double3(-8.9208187539523749, 0.0, 10.079181246047623), log10(double3(1.2E-09, 1.0, 12000000000.0)), 32, false);
@@ -1384,14 +1384,14 @@ public static void log10_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), log10(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void log10_double4()
         {
             TestUtils.AreEqual(double4(-8.9208187539523749, 0.0, 10.079181246047623, TestUtils.SignedDoubleQNaN()), log10(double4(1.2E-09, 1.0, 12000000000.0, -1.0)), 32, false);
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), log10(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 32, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void radians_float()
         {
             TestUtils.AreEqual(-2.154609f, radians(-123.45f), 1, false);
@@ -1402,7 +1402,7 @@ public static void radians_float()
             TestUtils.AreEqual(float.PositiveInfinity, radians(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void radians_float2()
         {
             TestUtils.AreEqual(float2(-2.154609f, 0f), radians(float2(-123.45f, 0f)), 1, false);
@@ -1410,21 +1410,21 @@ public static void radians_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), radians(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void radians_float3()
         {
             TestUtils.AreEqual(float3(-2.154609f, 0f, 2.154609f), radians(float3(-123.45f, 0f, 123.45f)), 1, false);
             TestUtils.AreEqual(float3(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity), radians(float3(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void radians_float4()
         {
             TestUtils.AreEqual(float4(-2.154609f, 0f, 2.154609f, float.NegativeInfinity), radians(float4(-123.45f, 0f, 123.45f, float.NegativeInfinity)), 1, false);
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), radians(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void radians_double()
         {
             TestUtils.AreEqual(-2.154608961587, radians(-123.45), 1, false);
@@ -1435,7 +1435,7 @@ public static void radians_double()
             TestUtils.AreEqual(double.PositiveInfinity, radians(double.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void radians_double2()
         {
             TestUtils.AreEqual(double2(-2.154608961587, 0.0), radians(double2(-123.45, 0.0)), 1, false);
@@ -1443,21 +1443,21 @@ public static void radians_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), radians(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void radians_double3()
         {
             TestUtils.AreEqual(double3(-2.154608961587, 0.0, 2.154608961587), radians(double3(-123.45, 0.0, 123.45)), 1, false);
             TestUtils.AreEqual(double3(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), radians(double3(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void radians_double4()
         {
             TestUtils.AreEqual(double4(-2.154608961587, 0.0, 2.154608961587, double.NegativeInfinity), radians(double4(-123.45, 0.0, 123.45, double.NegativeInfinity)), 1, false);
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), radians(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void degrees_float()
         {
             TestUtils.AreEqual(-7073.164f, degrees(-123.45f), 1, false);
@@ -1468,7 +1468,7 @@ public static void degrees_float()
             TestUtils.AreEqual(float.PositiveInfinity, degrees(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void degrees_float2()
         {
             TestUtils.AreEqual(float2(-7073.164f, 0f), degrees(float2(-123.45f, 0f)), 1, false);
@@ -1476,21 +1476,21 @@ public static void degrees_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), degrees(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void degrees_float3()
         {
             TestUtils.AreEqual(float3(-7073.164f, 0f, 7073.164f), degrees(float3(-123.45f, 0f, 123.45f)), 1, false);
             TestUtils.AreEqual(float3(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity), degrees(float3(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void degrees_float4()
         {
             TestUtils.AreEqual(float4(-7073.164f, 0f, 7073.164f, float.NegativeInfinity), degrees(float4(-123.45f, 0f, 123.45f, float.NegativeInfinity)), 1, false);
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), degrees(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void degrees_double()
         {
             TestUtils.AreEqual(-7073.1639808900127, degrees(-123.45), 1, false);
@@ -1501,7 +1501,7 @@ public static void degrees_double()
             TestUtils.AreEqual(double.PositiveInfinity, degrees(double.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void degrees_double2()
         {
             TestUtils.AreEqual(double2(-7073.1639808900127, 0.0), degrees(double2(-123.45, 0.0)), 1, false);
@@ -1509,21 +1509,21 @@ public static void degrees_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), degrees(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void degrees_double3()
         {
             TestUtils.AreEqual(double3(-7073.1639808900127, 0.0, 7073.1639808900127), degrees(double3(-123.45, 0.0, 123.45)), 1, false);
             TestUtils.AreEqual(double3(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), degrees(double3(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void degrees_double4()
         {
             TestUtils.AreEqual(double4(-7073.1639808900127, 0.0, 7073.1639808900127, double.NegativeInfinity), degrees(double4(-123.45, 0.0, 123.45, double.NegativeInfinity)), 1, false);
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), degrees(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sign_int()
         {
             TestUtils.AreEqual(-1, sign(-156));
@@ -1540,7 +1540,7 @@ public static void sign_int()
             TestUtils.AreEqual(-1, sign(-2147483648));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sign_int2()
         {
             TestUtils.AreEqual(int2(-1, -1), sign(int2(-156, -214748346)));
@@ -1551,7 +1551,7 @@ public static void sign_int2()
             TestUtils.AreEqual(int2(1, -1), sign(int2(2147483647, -2147483648)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sign_int3()
         {
             TestUtils.AreEqual(int3(-1, -1, 0), sign(int3(-156, -214748346, 0)));
@@ -1560,7 +1560,7 @@ public static void sign_int3()
             TestUtils.AreEqual(int3(1, 1, -1), sign(int3(64583, 2147483647, -2147483648)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sign_int4()
         {
             TestUtils.AreEqual(int4(-1, -1, 0, 1), sign(int4(-156, -214748346, 0, 214748346)));
@@ -1568,7 +1568,7 @@ public static void sign_int4()
             TestUtils.AreEqual(int4(-1, 1, 1, -1), sign(int4(-15379, 64583, 2147483647, -2147483648)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sign_float()
         {
             TestUtils.AreEqual(-1f, sign(-123.45f));
@@ -1581,7 +1581,7 @@ public static void sign_float()
             TestUtils.AreEqual(1f, sign(float.PositiveInfinity));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sign_float2()
         {
             TestUtils.AreEqual(float2(-1f, -1f), sign(float2(-123.45f, -1E-20f)));
@@ -1590,7 +1590,7 @@ public static void sign_float2()
             TestUtils.AreEqual(float2(0f, 1f), sign(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sign_float3()
         {
             TestUtils.AreEqual(float3(-1f, -1f, 0f), sign(float3(-123.45f, -1E-20f, 0f)));
@@ -1598,14 +1598,14 @@ public static void sign_float3()
             TestUtils.AreEqual(float3(0f, 1f, 1f), sign(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sign_float4()
         {
             TestUtils.AreEqual(float4(-1f, -1f, 0f, 1f), sign(float4(-123.45f, -1E-20f, 0f, 1E-10f)));
             TestUtils.AreEqual(float4(1f, -1f, 0f, 1f), sign(float4(123.45f, float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sign_double()
         {
             TestUtils.AreEqual(-1.0, sign(-123.45));
@@ -1618,7 +1618,7 @@ public static void sign_double()
             TestUtils.AreEqual(1.0, sign(double.PositiveInfinity));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sign_double2()
         {
             TestUtils.AreEqual(double2(-1.0, -1.0), sign(double2(-123.45, -1E-20)));
@@ -1627,7 +1627,7 @@ public static void sign_double2()
             TestUtils.AreEqual(double2(0.0, 1.0), sign(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sign_double3()
         {
             TestUtils.AreEqual(double3(-1.0, -1.0, 0.0), sign(double3(-123.45, -1E-20, 0.0)));
@@ -1635,14 +1635,14 @@ public static void sign_double3()
             TestUtils.AreEqual(double3(0.0, 1.0, 1.0), sign(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sign_double4()
         {
             TestUtils.AreEqual(double4(-1.0, -1.0, 0.0, 1.0), sign(double4(-123.45, -1E-20, 0.0, 1E-10)));
             TestUtils.AreEqual(double4(1.0, -1.0, 0.0, 1.0), sign(double4(123.45, double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sqrt_float()
         {
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), sqrt(-1f), 1, false);
@@ -1654,7 +1654,7 @@ public static void sqrt_float()
             TestUtils.AreEqual(float.PositiveInfinity, sqrt(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sqrt_float2()
         {
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), 0f), sqrt(float2(-1f, 0f)), 1, false);
@@ -1663,7 +1663,7 @@ public static void sqrt_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), sqrt(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sqrt_float3()
         {
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 0f, 1E-05f), sqrt(float3(-1f, 0f, 1E-10f)), 1, false);
@@ -1671,14 +1671,14 @@ public static void sqrt_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity), sqrt(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sqrt_float4()
         {
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), 0f, 1E-05f, 11.1108055f), sqrt(float4(-1f, 0f, 1E-10f, 123.45f)), 1, false);
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity), sqrt(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sqrt_double()
         {
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), sqrt(-1.0), 1, false);
@@ -1690,7 +1690,7 @@ public static void sqrt_double()
             TestUtils.AreEqual(double.PositiveInfinity, sqrt(double.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sqrt_double2()
         {
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), 0.0), sqrt(double2(-1.0, 0.0)), 1, false);
@@ -1699,7 +1699,7 @@ public static void sqrt_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), sqrt(double2(double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sqrt_double3()
         {
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 0.0, 1E-05), sqrt(double3(-1.0, 0.0, 1E-10)), 1, false);
@@ -1707,14 +1707,14 @@ public static void sqrt_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity), sqrt(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void sqrt_double4()
         {
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), 0.0, 1E-05, 11.11080555135405), sqrt(double4(-1.0, 0.0, 1E-10, 123.45)), 1, false);
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity), sqrt(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rsqrt_float()
         {
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), rsqrt(-1f), 1, false);
@@ -1726,7 +1726,7 @@ public static void rsqrt_float()
             TestUtils.AreEqual(0f, rsqrt(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rsqrt_float2()
         {
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), float.PositiveInfinity), rsqrt(float2(-1f, 0f)), 1, false);
@@ -1735,7 +1735,7 @@ public static void rsqrt_float2()
             TestUtils.AreEqual(float2(0f, 0f), rsqrt(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rsqrt_float3()
         {
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, 1E-05f), rsqrt(float3(-1f, 0f, 1E+10f)), 1, false);
@@ -1743,14 +1743,14 @@ public static void rsqrt_float3()
             TestUtils.AreEqual(float3(0f, 0f, 0f), rsqrt(float3(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rsqrt_float4()
         {
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, 1E-05f, 0.09000248f), rsqrt(float4(-1f, 0f, 1E+10f, 123.45f)), 1, false);
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), 0f, 0f), rsqrt(float4(float.NegativeInfinity, TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rsqrt_double()
         {
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), rsqrt(-1.0), 1, false);
@@ -1762,7 +1762,7 @@ public static void rsqrt_double()
             TestUtils.AreEqual(0.0, rsqrt(double.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rsqrt_double2()
         {
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity), rsqrt(double2(-1.0, 0.0)), 1, false);
@@ -1771,7 +1771,7 @@ public static void rsqrt_double2()
             TestUtils.AreEqual(double2(0.0, 0.0), rsqrt(double2(double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rsqrt_double3()
         {
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, 1E-05), rsqrt(double3(-1.0, 0.0, 10000000000.0)), 1, false);
@@ -1779,14 +1779,14 @@ public static void rsqrt_double3()
             TestUtils.AreEqual(double3(0.0, 0.0, 0.0), rsqrt(double3(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rsqrt_double4()
         {
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, 1E-05, 0.090002475102098425), rsqrt(double4(-1.0, 0.0, 10000000000.0, 123.45)), 1, false);
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), 0.0, 0.0), rsqrt(double4(double.NegativeInfinity, TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rcp_float()
         {
             TestUtils.AreEqual(-0.008100445f, rcp(-123.45f), 1, false);
@@ -1796,7 +1796,7 @@ public static void rcp_float()
             TestUtils.AreEqual(0f, rcp(float.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rcp_float2()
         {
             TestUtils.AreEqual(float2(-0.008100445f, float.PositiveInfinity), rcp(float2(-123.45f, 0f)), 1, false);
@@ -1804,21 +1804,21 @@ public static void rcp_float2()
             TestUtils.AreEqual(float2(0f, 0f), rcp(float2(float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rcp_float3()
         {
             TestUtils.AreEqual(float3(-0.008100445f, float.PositiveInfinity, 0.008100445f), rcp(float3(-123.45f, 0f, 123.45f)), 1, false);
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 0f, 0f), rcp(float3(TestUtils.SignedFloatQNaN(), float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rcp_float4()
         {
             TestUtils.AreEqual(float4(-0.008100445f, float.PositiveInfinity, 0.008100445f, TestUtils.SignedFloatQNaN()), rcp(float4(-123.45f, 0f, 123.45f, TestUtils.SignedFloatQNaN())), 1, false);
             TestUtils.AreEqual(float4(0f, 0f, 0f, 0f), rcp(float4(float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity, float.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rcp_double()
         {
             TestUtils.AreEqual(-0.0081004455245038479, rcp(-123.45), 1, false);
@@ -1828,7 +1828,7 @@ public static void rcp_double()
             TestUtils.AreEqual(0.0, rcp(double.PositiveInfinity), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rcp_double2()
         {
             TestUtils.AreEqual(double2(-0.0081004455245038479, double.PositiveInfinity), rcp(double2(-123.45, 0.0)), 1, false);
@@ -1836,21 +1836,21 @@ public static void rcp_double2()
             TestUtils.AreEqual(double2(0.0, 0.0), rcp(double2(double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rcp_double3()
         {
             TestUtils.AreEqual(double3(-0.0081004455245038479, double.PositiveInfinity, 0.0081004455245038479), rcp(double3(-123.45, 0.0, 123.45)), 1, false);
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 0.0, 0.0), rcp(double3(TestUtils.SignedDoubleQNaN(), double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rcp_double4()
         {
             TestUtils.AreEqual(double4(-0.0081004455245038479, double.PositiveInfinity, 0.0081004455245038479, TestUtils.SignedDoubleQNaN()), rcp(double4(-123.45, 0.0, 123.45, TestUtils.SignedDoubleQNaN())), 1, false);
             TestUtils.AreEqual(double4(0.0, 0.0, 0.0, 0.0), rcp(double4(double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity, double.PositiveInfinity)), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void floor_float()
         {
             TestUtils.AreEqual(float.NegativeInfinity, floor(float.NegativeInfinity));
@@ -1865,7 +1865,7 @@ public static void floor_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), floor(TestUtils.SignedFloatQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void floor_float2()
         {
             TestUtils.AreEqual(float2(float.NegativeInfinity, -101f), floor(float2(float.NegativeInfinity, -100.51f)));
@@ -1875,7 +1875,7 @@ public static void floor_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN()), floor(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void floor_float3()
         {
             TestUtils.AreEqual(float3(float.NegativeInfinity, -101f, -101f), floor(float3(float.NegativeInfinity, -100.51f, -100.5f)));
@@ -1884,7 +1884,7 @@ public static void floor_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), floor(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void floor_float4()
         {
             TestUtils.AreEqual(float4(float.NegativeInfinity, -101f, -101f, -101f), floor(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f)));
@@ -1892,7 +1892,7 @@ public static void floor_float4()
             TestUtils.AreEqual(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), floor(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void floor_double()
         {
             TestUtils.AreEqual(double.NegativeInfinity, floor(double.NegativeInfinity));
@@ -1907,7 +1907,7 @@ public static void floor_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), floor(TestUtils.SignedDoubleQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void floor_double2()
         {
             TestUtils.AreEqual(double2(double.NegativeInfinity, -101.0), floor(double2(double.NegativeInfinity, -100.51)));
@@ -1917,7 +1917,7 @@ public static void floor_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN()), floor(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void floor_double3()
         {
             TestUtils.AreEqual(double3(double.NegativeInfinity, -101.0, -101.0), floor(double3(double.NegativeInfinity, -100.51, -100.5)));
@@ -1926,7 +1926,7 @@ public static void floor_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), floor(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void floor_double4()
         {
             TestUtils.AreEqual(double4(double.NegativeInfinity, -101.0, -101.0, -101.0), floor(double4(double.NegativeInfinity, -100.51, -100.5, -100.49)));
@@ -1934,7 +1934,7 @@ public static void floor_double4()
             TestUtils.AreEqual(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), floor(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceil_float()
         {
             TestUtils.AreEqual(float.NegativeInfinity, ceil(float.NegativeInfinity));
@@ -1949,7 +1949,7 @@ public static void ceil_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), ceil(TestUtils.SignedFloatQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceil_float2()
         {
             TestUtils.AreEqual(float2(float.NegativeInfinity, -100f), ceil(float2(float.NegativeInfinity, -100.51f)));
@@ -1959,7 +1959,7 @@ public static void ceil_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN()), ceil(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceil_float3()
         {
             TestUtils.AreEqual(float3(float.NegativeInfinity, -100f, -100f), ceil(float3(float.NegativeInfinity, -100.51f, -100.5f)));
@@ -1968,7 +1968,7 @@ public static void ceil_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), ceil(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceil_float4()
         {
             TestUtils.AreEqual(float4(float.NegativeInfinity, -100f, -100f, -100f), ceil(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f)));
@@ -1976,7 +1976,7 @@ public static void ceil_float4()
             TestUtils.AreEqual(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), ceil(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceil_double()
         {
             TestUtils.AreEqual(double.NegativeInfinity, ceil(double.NegativeInfinity));
@@ -1991,7 +1991,7 @@ public static void ceil_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), ceil(TestUtils.SignedDoubleQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceil_double2()
         {
             TestUtils.AreEqual(double2(double.NegativeInfinity, -100.0), ceil(double2(double.NegativeInfinity, -100.51)));
@@ -2001,7 +2001,7 @@ public static void ceil_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN()), ceil(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceil_double3()
         {
             TestUtils.AreEqual(double3(double.NegativeInfinity, -100.0, -100.0), ceil(double3(double.NegativeInfinity, -100.51, -100.5)));
@@ -2010,7 +2010,7 @@ public static void ceil_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), ceil(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceil_double4()
         {
             TestUtils.AreEqual(double4(double.NegativeInfinity, -100.0, -100.0, -100.0), ceil(double4(double.NegativeInfinity, -100.51, -100.5, -100.49)));
@@ -2018,7 +2018,7 @@ public static void ceil_double4()
             TestUtils.AreEqual(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), ceil(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void round_float()
         {
             TestUtils.AreEqual(float.NegativeInfinity, round(float.NegativeInfinity));
@@ -2034,7 +2034,7 @@ public static void round_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), round(TestUtils.SignedFloatQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void round_float2()
         {
             TestUtils.AreEqual(float2(float.NegativeInfinity, -101f), round(float2(float.NegativeInfinity, -100.51f)));
@@ -2045,7 +2045,7 @@ public static void round_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), round(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void round_float3()
         {
             TestUtils.AreEqual(float3(float.NegativeInfinity, -101f, -100f), round(float3(float.NegativeInfinity, -100.51f, -100.5f)));
@@ -2054,7 +2054,7 @@ public static void round_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), round(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void round_float4()
         {
             TestUtils.AreEqual(float4(float.NegativeInfinity, -101f, -100f, -100f), round(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f)));
@@ -2062,7 +2062,7 @@ public static void round_float4()
             TestUtils.AreEqual(float4(102f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), round(float4(101.5f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void round_double()
         {
             TestUtils.AreEqual(double.NegativeInfinity, round(double.NegativeInfinity));
@@ -2078,7 +2078,7 @@ public static void round_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), round(TestUtils.SignedDoubleQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void round_double2()
         {
             TestUtils.AreEqual(double2(double.NegativeInfinity, -101.0), round(double2(double.NegativeInfinity, -100.51)));
@@ -2089,7 +2089,7 @@ public static void round_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), round(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void round_double3()
         {
             TestUtils.AreEqual(double3(double.NegativeInfinity, -101.0, -100.0), round(double3(double.NegativeInfinity, -100.51, -100.5)));
@@ -2098,7 +2098,7 @@ public static void round_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), round(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void round_double4()
         {
             TestUtils.AreEqual(double4(double.NegativeInfinity, -101.0, -100.0, -100.0), round(double4(double.NegativeInfinity, -100.51, -100.5, -100.49)));
@@ -2106,7 +2106,7 @@ public static void round_double4()
             TestUtils.AreEqual(double4(102.0, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), round(double4(101.5, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void trunc_float()
         {
             TestUtils.AreEqual(float.NegativeInfinity, trunc(float.NegativeInfinity));
@@ -2122,7 +2122,7 @@ public static void trunc_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), trunc(TestUtils.SignedFloatQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void trunc_float2()
         {
             TestUtils.AreEqual(float2(float.NegativeInfinity, -100f), trunc(float2(float.NegativeInfinity, -100.51f)));
@@ -2133,7 +2133,7 @@ public static void trunc_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), trunc(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void trunc_float3()
         {
             TestUtils.AreEqual(float3(float.NegativeInfinity, -100f, -100f), trunc(float3(float.NegativeInfinity, -100.51f, -100.5f)));
@@ -2142,7 +2142,7 @@ public static void trunc_float3()
             TestUtils.AreEqual(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), trunc(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void trunc_float4()
         {
             TestUtils.AreEqual(float4(float.NegativeInfinity, -100f, -100f, -100f), trunc(float4(float.NegativeInfinity, -100.51f, -100.5f, -100.49f)));
@@ -2150,7 +2150,7 @@ public static void trunc_float4()
             TestUtils.AreEqual(float4(101f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), trunc(float4(101.5f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void trunc_double()
         {
             TestUtils.AreEqual(double.NegativeInfinity, trunc(double.NegativeInfinity));
@@ -2166,7 +2166,7 @@ public static void trunc_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), trunc(TestUtils.SignedDoubleQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void trunc_double2()
         {
             TestUtils.AreEqual(double2(double.NegativeInfinity, -100.0), trunc(double2(double.NegativeInfinity, -100.51)));
@@ -2177,7 +2177,7 @@ public static void trunc_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), trunc(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void trunc_double3()
         {
             TestUtils.AreEqual(double3(double.NegativeInfinity, -100.0, -100.0), trunc(double3(double.NegativeInfinity, -100.51, -100.5)));
@@ -2186,7 +2186,7 @@ public static void trunc_double3()
             TestUtils.AreEqual(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), trunc(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void trunc_double4()
         {
             TestUtils.AreEqual(double4(double.NegativeInfinity, -100.0, -100.0, -100.0), trunc(double4(double.NegativeInfinity, -100.51, -100.5, -100.49)));
@@ -2194,7 +2194,7 @@ public static void trunc_double4()
             TestUtils.AreEqual(double4(101.0, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), trunc(double4(101.5, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void frac_float()
         {
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), frac(float.NegativeInfinity), 64, false);
@@ -2206,7 +2206,7 @@ public static void frac_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), frac(TestUtils.SignedFloatQNaN()), 64, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void frac_float2()
         {
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), 0f), frac(float2(float.NegativeInfinity, -1E+20f)), 64, false);
@@ -2215,7 +2215,7 @@ public static void frac_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), frac(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 64, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void frac_float3()
         {
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), 0f, 0.7f), frac(float3(float.NegativeInfinity, -1E+20f, -100.3f)), 64, false);
@@ -2223,14 +2223,14 @@ public static void frac_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), frac(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 64, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void frac_float4()
         {
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), 0f, 0.7f, 0f), frac(float4(float.NegativeInfinity, -1E+20f, -100.3f, 0f)), 64, false);
             TestUtils.AreEqual(float4(0.8f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), frac(float4(100.8f, float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 64, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void frac_double()
         {
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), frac(double.NegativeInfinity), 64, false);
@@ -2242,7 +2242,7 @@ public static void frac_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), frac(TestUtils.SignedDoubleQNaN()), 64, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void frac_double2()
         {
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), 0.0), frac(double2(double.NegativeInfinity, -1E+20)), 64, false);
@@ -2251,7 +2251,7 @@ public static void frac_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), frac(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 64, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void frac_double3()
         {
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), 0.0, 0.7), frac(double3(double.NegativeInfinity, -1E+20, -100.3)), 64, false);
@@ -2259,14 +2259,14 @@ public static void frac_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), frac(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 64, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void frac_double4()
         {
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), 0.0, 0.7, 0.0), frac(double4(double.NegativeInfinity, -1E+20, -100.3, 0.0)), 64, false);
             TestUtils.AreEqual(double4(0.8, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), frac(double4(100.8, double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 64, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lerp_float()
         {
             TestUtils.AreEqual(-967.77f, lerp(-123.45f, 439.43f, -1.5f), 1, false);
@@ -2275,27 +2275,27 @@ public static void lerp_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), lerp(-123.45f, 439.43f, TestUtils.SignedFloatQNaN()), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lerp_float2()
         {
             TestUtils.AreEqual(float2(-967.77f, 157.99f), lerp(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(-1.5f, 0.5f)), 1, false);
             TestUtils.AreEqual(float2(2972.39f, TestUtils.SignedFloatQNaN()), lerp(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(5.5f, TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lerp_float3()
         {
             TestUtils.AreEqual(float3(-967.77f, 157.99f, 2972.39f), lerp(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(-1.5f, 0.5f, 5.5f)), 1, false);
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), lerp(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lerp_float4()
         {
             TestUtils.AreEqual(float4(-967.77f, 157.99f, 2972.39f, TestUtils.SignedFloatQNaN()), lerp(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, 439.43f, 439.43f, 439.43f), float4(-1.5f, 0.5f, 5.5f, TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lerp_double()
         {
             TestUtils.AreEqual(-967.77, lerp(-123.45, 439.43, -1.5), 1, false);
@@ -2304,27 +2304,27 @@ public static void lerp_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), lerp(-123.45, 439.43, TestUtils.SignedDoubleQNaN()), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lerp_double2()
         {
             TestUtils.AreEqual(double2(-967.77, 157.99), lerp(double2(-123.45, -123.45), double2(439.43, 439.43), double2(-1.5, 0.5)), 1, false);
             TestUtils.AreEqual(double2(2972.39, TestUtils.SignedDoubleQNaN()), lerp(double2(-123.45, -123.45), double2(439.43, 439.43), double2(5.5, TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lerp_double3()
         {
             TestUtils.AreEqual(double3(-967.77, 157.99, 2972.39), lerp(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(-1.5, 0.5, 5.5)), 1, false);
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), lerp(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void lerp_double4()
         {
             TestUtils.AreEqual(double4(-967.77, 157.99, 2972.39, TestUtils.SignedDoubleQNaN()), lerp(double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, 439.43, 439.43, 439.43), double4(-1.5, 0.5, 5.5, TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void unlerp_float()
         {
             TestUtils.AreEqual(-0.232465178f, unlerp(-123.45f, 439.43f, -254.3f), 4, false);
@@ -2337,7 +2337,7 @@ public static void unlerp_float()
             TestUtils.AreEqual(-0.3422932f, unlerp(439.43f, -123.45f, 632.1f), 4, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void unlerp_float2()
         {
             TestUtils.AreEqual(float2(-0.232465178f, 0.219318509f), unlerp(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(-254.3f, 0f)), 4, false);
@@ -2346,7 +2346,7 @@ public static void unlerp_float2()
             TestUtils.AreEqual(float2(0.7806815f, -0.3422932f), unlerp(float2(439.43f, 439.43f), float2(-123.45f, -123.45f), float2(0f, 632.1f)), 4, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void unlerp_float3()
         {
             TestUtils.AreEqual(float3(-0.232465178f, 0.219318509f, 1.34229326f), unlerp(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(-254.3f, 0f, 632.1f)), 4, false);
@@ -2354,14 +2354,14 @@ public static void unlerp_float3()
             TestUtils.AreEqual(float3(0.7806815f, -0.3422932f, -0.3422932f), unlerp(float3(439.43f, 439.43f, 439.43f), float3(-123.45f, -123.45f, -123.45f), float3(0f, 632.1f, 632.1f)), 4, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void unlerp_float4()
         {
             TestUtils.AreEqual(float4(-0.232465178f, 0.219318509f, 1.34229326f, float.NegativeInfinity), unlerp(float4(-123.45f, -123.45f, -123.45f, 123.4f), float4(439.43f, 439.43f, 439.43f, 123.4f), float4(-254.3f, 0f, 632.1f, -430f)), 4, false);
             TestUtils.AreEqual(float4(float.PositiveInfinity, 1.23246515f, 0.7806815f, -0.3422932f), unlerp(float4(123.4f, 439.43f, 439.43f, 439.43f), float4(123.4f, -123.45f, -123.45f, -123.45f), float4(430f, -254.3f, 0f, 632.1f)), 4, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void unlerp_double()
         {
             TestUtils.AreEqual(-0.23246517907902217, unlerp(-123.45, 439.43, -254.3), 4, false);
@@ -2374,7 +2374,7 @@ public static void unlerp_double()
             TestUtils.AreEqual(-0.34229320636725413, unlerp(439.43, -123.45, 632.1), 4, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void unlerp_double2()
         {
             TestUtils.AreEqual(double2(-0.23246517907902217, 0.21931850483229107), unlerp(double2(-123.45, -123.45), double2(439.43, 439.43), double2(-254.3, 0.0)), 4, false);
@@ -2383,7 +2383,7 @@ public static void unlerp_double2()
             TestUtils.AreEqual(double2(0.78068149516770891, -0.34229320636725413), unlerp(double2(439.43, 439.43), double2(-123.45, -123.45), double2(0.0, 632.1)), 4, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void unlerp_double3()
         {
             TestUtils.AreEqual(double3(-0.23246517907902217, 0.21931850483229107, 1.3422932063672541), unlerp(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(-254.3, 0.0, 632.1)), 4, false);
@@ -2391,14 +2391,14 @@ public static void unlerp_double3()
             TestUtils.AreEqual(double3(0.78068149516770891, -0.34229320636725413, -0.34229320636725413), unlerp(double3(439.43, 439.43, 439.43), double3(-123.45, -123.45, -123.45), double3(0.0, 632.1, 632.1)), 4, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void unlerp_double4()
         {
             TestUtils.AreEqual(double4(-0.23246517907902217, 0.21931850483229107, 1.3422932063672541, double.NegativeInfinity), unlerp(double4(-123.45, -123.45, -123.45, 123.4), double4(439.43, 439.43, 439.43, 123.4), double4(-254.3, 0.0, 632.1, -430.0)), 4, false);
             TestUtils.AreEqual(double4(double.PositiveInfinity, 1.2324651790790222, 0.78068149516770891, -0.34229320636725413), unlerp(double4(123.4, 439.43, 439.43, 439.43), double4(123.4, -123.45, -123.45, -123.45), double4(430.0, -254.3, 0.0, 632.1)), 4, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void remap_float()
         {
             TestUtils.AreEqual(529.0331f, remap(-123.45f, 439.43f, 541.3f, 631.5f, -200f), 4, false);
@@ -2414,7 +2414,7 @@ public static void remap_float()
             TestUtils.AreEqual(float.PositiveInfinity, remap(-123.45f, -123.45f, 541.3f, 631.5f, -100f), 4, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void remap_float2()
         {
             TestUtils.AreEqual(float2(529.0331f, 545.0578f), remap(float2(-123.45f, -123.45f), float2(439.43f, 439.43f), float2(541.3f, 541.3f), float2(631.5f, 631.5f), float2(-200f, -100f)), 4, false);
@@ -2425,7 +2425,7 @@ public static void remap_float2()
             TestUtils.AreEqual(float2(float.PositiveInfinity, float.PositiveInfinity), remap(float2(-123.45f, -123.45f), float2(-123.45f, -123.45f), float2(541.3f, 541.3f), float2(631.5f, 631.5f), float2(-100f, -100f)), 4, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void remap_float3()
         {
             TestUtils.AreEqual(float3(529.0331f, 545.0578f, 641.2062f), remap(float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f), float3(541.3f, 541.3f, 541.3f), float3(631.5f, 631.5f, 631.5f), float3(-200f, -100f, 500f)), 4, false);
@@ -2434,7 +2434,7 @@ public static void remap_float3()
             TestUtils.AreEqual(float3(float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity), remap(float3(-123.45f, -123.45f, -123.45f), float3(-123.45f, -123.45f, -123.45f), float3(541.3f, 541.3f, 541.3f), float3(631.5f, 631.5f, 631.5f), float3(-200f, -100f, -100f)), 4, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void remap_float4()
         {
             TestUtils.AreEqual(float4(529.0331f, 545.0578f, 641.2062f, 643.7669f), remap(float4(-123.45f, -123.45f, -123.45f, 439.43f), float4(439.43f, 439.43f, 439.43f, -123.45f), float4(541.3f, 541.3f, 541.3f, 541.3f), float4(631.5f, 631.5f, 631.5f, 631.5f), float4(-200f, -100f, 500f, -200f)), 4, false);
@@ -2442,7 +2442,7 @@ public static void remap_float4()
             TestUtils.AreEqual(float4(531.5938f, float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity), remap(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, -123.45f, -123.45f, -123.45f), float4(631.5f, 541.3f, 541.3f, 541.3f), float4(541.3f, 631.5f, 631.5f, 631.5f), float4(500f, -200f, -100f, -100f)), 4, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void remap_double()
         {
             TestUtils.AreEqual(529.03306921546334, remap(-123.45, 439.43, 541.3, 631.5, -200.0), 4, false);
@@ -2458,7 +2458,7 @@ public static void remap_double()
             TestUtils.AreEqual(double.PositiveInfinity, remap(-123.45, -123.45, 541.3, 631.5, -100.0), 4, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void remap_double2()
         {
             TestUtils.AreEqual(double2(529.03306921546334, 545.057799175668), remap(double2(-123.45, -123.45), double2(439.43, 439.43), double2(541.3, 541.3), double2(631.5, 631.5), double2(-200.0, -100.0)), 4, false);
@@ -2469,7 +2469,7 @@ public static void remap_double2()
             TestUtils.AreEqual(double2(double.PositiveInfinity, double.PositiveInfinity), remap(double2(-123.45, -123.45), double2(-123.45, -123.45), double2(541.3, 541.3), double2(631.5, 631.5), double2(-100.0, -100.0)), 4, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void remap_double3()
         {
             TestUtils.AreEqual(double3(529.03306921546334, 545.057799175668, 641.206178936896), remap(double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43), double3(541.3, 541.3, 541.3), double3(631.5, 631.5, 631.5), double3(-200.0, -100.0, 500.0)), 4, false);
@@ -2478,7 +2478,7 @@ public static void remap_double3()
             TestUtils.AreEqual(double3(double.NegativeInfinity, double.PositiveInfinity, double.PositiveInfinity), remap(double3(-123.45, -123.45, -123.45), double3(-123.45, -123.45, -123.45), double3(541.3, 541.3, 541.3), double3(631.5, 631.5, 631.5), double3(-200.0, -100.0, -100.0)), 4, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void remap_double4()
         {
             TestUtils.AreEqual(double4(529.03306921546334, 545.057799175668, 641.206178936896, 643.76693078453673), remap(double4(-123.45, -123.45, -123.45, 439.43), double4(439.43, 439.43, 439.43, -123.45), double4(541.3, 541.3, 541.3, 541.3), double4(631.5, 631.5, 631.5, 631.5), double4(-200.0, -100.0, 500.0, -200.0)), 4, false);
@@ -2486,7 +2486,7 @@ public static void remap_double4()
             TestUtils.AreEqual(double4(531.59382106310409, double.NegativeInfinity, double.PositiveInfinity, double.PositiveInfinity), remap(double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, -123.45, -123.45, -123.45), double4(631.5, 541.3, 541.3, 541.3), double4(541.3, 631.5, 631.5, 631.5), double4(500.0, -200.0, -100.0, -100.0)), 4, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_int()
         {
             TestUtils.AreEqual(-123, clamp(-2147483648, -123, 439));
@@ -2499,7 +2499,7 @@ public static void clamp_int()
             TestUtils.AreEqual(439, clamp(2147483647, -123, 439));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_int2()
         {
             TestUtils.AreEqual(int2(-123, -123), clamp(int2(-2147483648, -254), int2(-123, -123), int2(439, 439)));
@@ -2508,7 +2508,7 @@ public static void clamp_int2()
             TestUtils.AreEqual(int2(439, 439), clamp(int2(632, 2147483647), int2(439, -123), int2(-123, 439)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_int3()
         {
             TestUtils.AreEqual(int3(-123, -123, 246), clamp(int3(-2147483648, -254, 246), int3(-123, -123, -123), int3(439, 439, 439)));
@@ -2516,14 +2516,14 @@ public static void clamp_int3()
             TestUtils.AreEqual(int3(439, 439, 439), clamp(int3(632, 2147483647, 2147483647), int3(439, -123, -123), int3(-123, 439, 439)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_int4()
         {
             TestUtils.AreEqual(int4(-123, -123, 246, 439), clamp(int4(-2147483648, -254, 246, 632), int4(-123, -123, -123, -123), int4(439, 439, 439, 439)));
             TestUtils.AreEqual(int4(439, 439, 439, 439), clamp(int4(-254, 246, 632, 2147483647), int4(439, 439, 439, -123), int4(-123, -123, -123, 439)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_uint()
         {
             TestUtils.AreEqual(123u, clamp(0u, 123u, 439u));
@@ -2536,7 +2536,7 @@ public static void clamp_uint()
             TestUtils.AreEqual(439u, clamp(4294967295u, 123u, 439u));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_uint2()
         {
             TestUtils.AreEqual(uint2(123u, 123u), clamp(uint2(0u, 54u), uint2(123u, 123u), uint2(439u, 439u)));
@@ -2545,7 +2545,7 @@ public static void clamp_uint2()
             TestUtils.AreEqual(uint2(439u, 439u), clamp(uint2(632u, 4294967295u), uint2(439u, 123u), uint2(123u, 439u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_uint3()
         {
             TestUtils.AreEqual(uint3(123u, 123u, 246u), clamp(uint3(0u, 54u, 246u), uint3(123u, 123u, 123u), uint3(439u, 439u, 439u)));
@@ -2553,14 +2553,14 @@ public static void clamp_uint3()
             TestUtils.AreEqual(uint3(439u, 439u, 439u), clamp(uint3(632u, 4294967295u, 4294967295u), uint3(439u, 123u, 123u), uint3(123u, 439u, 439u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_uint4()
         {
             TestUtils.AreEqual(uint4(123u, 123u, 246u, 439u), clamp(uint4(0u, 54u, 246u, 632u), uint4(123u, 123u, 123u, 123u), uint4(439u, 439u, 439u, 439u)));
             TestUtils.AreEqual(uint4(439u, 439u, 439u, 439u), clamp(uint4(54u, 246u, 632u, 4294967295u), uint4(439u, 439u, 439u, 123u), uint4(123u, 123u, 123u, 439u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_long()
         {
             TestUtils.AreEqual(-123L, clamp(-9223372036854775808L, -123L, 439L));
@@ -2573,7 +2573,7 @@ public static void clamp_long()
             TestUtils.AreEqual(439L, clamp(9223372036854775807L, -123L, 439L));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_ulong()
         {
             TestUtils.AreEqual(123UL, clamp(0UL, 123UL, 439UL));
@@ -2586,7 +2586,7 @@ public static void clamp_ulong()
             TestUtils.AreEqual(439UL, clamp(18446744073709551615UL, 123UL, 439UL));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_float()
         {
             TestUtils.AreEqual(-123.45f, clamp(float.NegativeInfinity, -123.45f, 439.43f));
@@ -2600,7 +2600,7 @@ public static void clamp_float()
             TestUtils.AreEqual(439.43f, clamp(TestUtils.SignedFloatQNaN(), -123.45f, 439.43f));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_float2()
         {
             TestUtils.AreEqual(float2(-123.45f, -123.45f), clamp(float2(float.NegativeInfinity, -254.3f), float2(-123.45f, -123.45f), float2(439.43f, 439.43f)));
@@ -2610,7 +2610,7 @@ public static void clamp_float2()
             TestUtils.AreEqual(float2(439.43f, 439.43f), clamp(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(-123.45f, -123.45f), float2(439.43f, 439.43f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_float3()
         {
             TestUtils.AreEqual(float3(-123.45f, -123.45f, 246.3f), clamp(float3(float.NegativeInfinity, -254.3f, 246.3f), float3(-123.45f, -123.45f, -123.45f), float3(439.43f, 439.43f, 439.43f)));
@@ -2618,7 +2618,7 @@ public static void clamp_float3()
             TestUtils.AreEqual(float3(439.43f, 439.43f, 439.43f), clamp(float3(632.1f, float.PositiveInfinity, TestUtils.SignedFloatQNaN()), float3(439.43f, -123.45f, -123.45f), float3(-123.45f, 439.43f, 439.43f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_float4()
         {
             TestUtils.AreEqual(float4(-123.45f, -123.45f, 246.3f, 439.43f), clamp(float4(float.NegativeInfinity, -254.3f, 246.3f, 632.1f), float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, 439.43f, 439.43f, 439.43f)));
@@ -2626,7 +2626,7 @@ public static void clamp_float4()
             TestUtils.AreEqual(float4(439.43f, 439.43f, 439.43f, 439.43f), clamp(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(439.43f, 439.43f, 439.43f, 439.43f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_double()
         {
             TestUtils.AreEqual(-123.45, clamp(double.NegativeInfinity, -123.45, 439.43));
@@ -2640,7 +2640,7 @@ public static void clamp_double()
             TestUtils.AreEqual(439.43, clamp(TestUtils.SignedDoubleQNaN(), -123.45, 439.43));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_double2()
         {
             TestUtils.AreEqual(double2(-123.45, -123.45), clamp(double2(double.NegativeInfinity, -254.3), double2(-123.45, -123.45), double2(439.43, 439.43)));
@@ -2650,7 +2650,7 @@ public static void clamp_double2()
             TestUtils.AreEqual(double2(439.43, 439.43), clamp(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(-123.45, -123.45), double2(439.43, 439.43)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_double3()
         {
             TestUtils.AreEqual(double3(-123.45, -123.45, 246.3), clamp(double3(double.NegativeInfinity, -254.3, 246.3), double3(-123.45, -123.45, -123.45), double3(439.43, 439.43, 439.43)));
@@ -2658,7 +2658,7 @@ public static void clamp_double3()
             TestUtils.AreEqual(double3(439.43, 439.43, 439.43), clamp(double3(632.1, double.PositiveInfinity, TestUtils.SignedDoubleQNaN()), double3(439.43, -123.45, -123.45), double3(-123.45, 439.43, 439.43)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void clamp_double4()
         {
             TestUtils.AreEqual(double4(-123.45, -123.45, 246.3, 439.43), clamp(double4(double.NegativeInfinity, -254.3, 246.3, 632.1), double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, 439.43, 439.43, 439.43)));
@@ -2666,7 +2666,7 @@ public static void clamp_double4()
             TestUtils.AreEqual(double4(439.43, 439.43, 439.43, 439.43), clamp(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(-123.45, -123.45, -123.45, -123.45), double4(439.43, 439.43, 439.43, 439.43)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void saturate_float()
         {
             TestUtils.AreEqual(0f, saturate(float.NegativeInfinity));
@@ -2679,7 +2679,7 @@ public static void saturate_float()
             TestUtils.AreEqual(1f, saturate(TestUtils.SignedFloatQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void saturate_float2()
         {
             TestUtils.AreEqual(float2(0f, 0f), saturate(float2(float.NegativeInfinity, -123.45f)));
@@ -2688,7 +2688,7 @@ public static void saturate_float2()
             TestUtils.AreEqual(float2(1f, 1f), saturate(float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void saturate_float3()
         {
             TestUtils.AreEqual(float3(0f, 0f, 0f), saturate(float3(float.NegativeInfinity, -123.45f, 0f)));
@@ -2696,14 +2696,14 @@ public static void saturate_float3()
             TestUtils.AreEqual(float3(1f, 1f, 1f), saturate(float3(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void saturate_float4()
         {
             TestUtils.AreEqual(float4(0f, 0f, 0f, 0.5f), saturate(float4(float.NegativeInfinity, -123.45f, 0f, 0.5f)));
             TestUtils.AreEqual(float4(1f, 1f, 1f, 1f), saturate(float4(1f, 123.45f, float.PositiveInfinity, TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void saturate_double()
         {
             TestUtils.AreEqual(0.0, saturate(double.NegativeInfinity));
@@ -2716,7 +2716,7 @@ public static void saturate_double()
             TestUtils.AreEqual(1.0, saturate(TestUtils.SignedDoubleQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void saturate_double2()
         {
             TestUtils.AreEqual(double2(0.0, 0.0), saturate(double2(double.NegativeInfinity, -123.45)));
@@ -2725,7 +2725,7 @@ public static void saturate_double2()
             TestUtils.AreEqual(double2(1.0, 1.0), saturate(double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void saturate_double3()
         {
             TestUtils.AreEqual(double3(0.0, 0.0, 0.0), saturate(double3(double.NegativeInfinity, -123.45, 0.0)));
@@ -2733,14 +2733,14 @@ public static void saturate_double3()
             TestUtils.AreEqual(double3(1.0, 1.0, 1.0), saturate(double3(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void saturate_double4()
         {
             TestUtils.AreEqual(double4(0.0, 0.0, 0.0, 0.5), saturate(double4(double.NegativeInfinity, -123.45, 0.0, 0.5)));
             TestUtils.AreEqual(double4(1.0, 1.0, 1.0, 1.0), saturate(double4(1.0, 123.45, double.PositiveInfinity, TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void step_float()
         {
             TestUtils.AreEqual(0f, step(-123.45f, float.NegativeInfinity));
@@ -2770,7 +2770,7 @@ public static void step_float()
             TestUtils.AreEqual(0f, step(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void step_float2()
         {
             TestUtils.AreEqual(float2(0f, 0f), step(float2(-123.45f, -123.45f), float2(float.NegativeInfinity, -200f)));
@@ -2788,7 +2788,7 @@ public static void step_float2()
             TestUtils.AreEqual(float2(0f, 0f), step(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void step_float3()
         {
             TestUtils.AreEqual(float3(0f, 0f, 1f), step(float3(-123.45f, -123.45f, -123.45f), float3(float.NegativeInfinity, -200f, 200f)));
@@ -2802,7 +2802,7 @@ public static void step_float3()
             TestUtils.AreEqual(float3(0f, 0f, 0f), step(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void step_float4()
         {
             TestUtils.AreEqual(float4(0f, 0f, 1f, 1f), step(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(float.NegativeInfinity, -200f, 200f, float.PositiveInfinity)));
@@ -2814,7 +2814,7 @@ public static void step_float4()
             TestUtils.AreEqual(float4(0f, 0f, 0f, 0f), step(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void step_double()
         {
             TestUtils.AreEqual(0.0, step(-123.45, double.NegativeInfinity));
@@ -2844,7 +2844,7 @@ public static void step_double()
             TestUtils.AreEqual(0.0, step(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void step_double2()
         {
             TestUtils.AreEqual(double2(0.0, 0.0), step(double2(-123.45, -123.45), double2(double.NegativeInfinity, -200.0)));
@@ -2862,7 +2862,7 @@ public static void step_double2()
             TestUtils.AreEqual(double2(0.0, 0.0), step(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void step_double3()
         {
             TestUtils.AreEqual(double3(0.0, 0.0, 1.0), step(double3(-123.45, -123.45, -123.45), double3(double.NegativeInfinity, -200.0, 200.0)));
@@ -2876,7 +2876,7 @@ public static void step_double3()
             TestUtils.AreEqual(double3(0.0, 0.0, 0.0), step(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void step_double4()
         {
             TestUtils.AreEqual(double4(0.0, 0.0, 1.0, 1.0), step(double4(-123.45, -123.45, -123.45, -123.45), double4(double.NegativeInfinity, -200.0, 200.0, double.PositiveInfinity)));
@@ -2888,7 +2888,7 @@ public static void step_double4()
             TestUtils.AreEqual(double4(0.0, 0.0, 0.0, 0.0), step(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_int()
         {
             TestUtils.AreEqual(-2147483648, min(-2147483648, -2147483648));
@@ -2906,7 +2906,7 @@ public static void min_int()
             TestUtils.AreEqual(2147483647, min(2147483647, 2147483647));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_int2()
         {
             TestUtils.AreEqual(int2(-2147483648, -2147483648), min(int2(-2147483648, -2147483648), int2(-2147483648, -1)));
@@ -2918,7 +2918,7 @@ public static void min_int2()
             TestUtils.AreEqual(int2(2147483647, 2147483647), min(int2(2147483647, 2147483647), int2(2147483647, 2147483647)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_int3()
         {
             TestUtils.AreEqual(int3(-2147483648, -2147483648, -2147483648), min(int3(-2147483648, -2147483648, -1), int3(-2147483648, -1, -2147483648)));
@@ -2928,7 +2928,7 @@ public static void min_int3()
             TestUtils.AreEqual(int3(2147483647, 2147483647, 2147483647), min(int3(2147483647, 2147483647, 2147483647), int3(2147483647, 2147483647, 2147483647)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_int4()
         {
             TestUtils.AreEqual(int4(-2147483648, -2147483648, -2147483648, -3456), min(int4(-2147483648, -2147483648, -1, -1234), int4(-2147483648, -1, -2147483648, -3456)));
@@ -2937,7 +2937,7 @@ public static void min_int4()
             TestUtils.AreEqual(int4(2147483647, 2147483647, 2147483647, 2147483647), min(int4(2147483647, 2147483647, 2147483647, 2147483647), int4(2147483647, 2147483647, 2147483647, 2147483647)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_uint()
         {
             TestUtils.AreEqual(1234u, min(1234u, 3456u));
@@ -2949,7 +2949,7 @@ public static void min_uint()
             TestUtils.AreEqual(4294967295u, min(4294967295u, 4294967295u));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_uint2()
         {
             TestUtils.AreEqual(uint2(1234u, 1234u), min(uint2(1234u, 3456u), uint2(3456u, 1234u)));
@@ -2958,7 +2958,7 @@ public static void min_uint2()
             TestUtils.AreEqual(uint2(4294967295u, 4294967295u), min(uint2(4294967295u, 4294967295u), uint2(4294967295u, 4294967295u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_uint3()
         {
             TestUtils.AreEqual(uint3(1234u, 1234u, 7u), min(uint3(1234u, 3456u, 4294967040u), uint3(3456u, 1234u, 7u)));
@@ -2966,14 +2966,14 @@ public static void min_uint3()
             TestUtils.AreEqual(uint3(4294967295u, 4294967295u, 4294967295u), min(uint3(4294967295u, 4294967295u, 4294967295u), uint3(4294967295u, 4294967295u, 4294967295u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_uint4()
         {
             TestUtils.AreEqual(uint4(1234u, 1234u, 7u, 7u), min(uint4(1234u, 3456u, 4294967040u, 7u), uint4(3456u, 1234u, 7u, 4294967040u)));
             TestUtils.AreEqual(uint4(1u, 1u, 4294967295u, 4294967295u), min(uint4(1u, 4294967295u, 4294967295u, 4294967295u), uint4(4294967295u, 1u, 4294967295u, 4294967295u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_long()
         {
             TestUtils.AreEqual(-9223372036854775808L, min(-9223372036854775808L, -9223372036854775808L));
@@ -2991,7 +2991,7 @@ public static void min_long()
             TestUtils.AreEqual(9223372036854775807L, min(9223372036854775807L, 9223372036854775807L));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_ulong()
         {
             TestUtils.AreEqual(1234UL, min(1234UL, 3456UL));
@@ -3003,7 +3003,7 @@ public static void min_ulong()
             TestUtils.AreEqual(18446744073709551615UL, min(18446744073709551615UL, 18446744073709551615UL));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_float()
         {
             TestUtils.AreEqual(float.NegativeInfinity, min(float.NegativeInfinity, float.NegativeInfinity));
@@ -3024,7 +3024,7 @@ public static void min_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), min(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_float2()
         {
             TestUtils.AreEqual(float2(float.NegativeInfinity, float.NegativeInfinity), min(float2(float.NegativeInfinity, float.NegativeInfinity), float2(float.NegativeInfinity, -1f)));
@@ -3037,7 +3037,7 @@ public static void min_float2()
             TestUtils.AreEqual(float2(2.3f, TestUtils.SignedFloatQNaN()), min(float2(2.3f, TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_float3()
         {
             TestUtils.AreEqual(float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity), min(float3(float.NegativeInfinity, float.NegativeInfinity, -1f), float3(float.NegativeInfinity, -1f, float.NegativeInfinity)));
@@ -3048,7 +3048,7 @@ public static void min_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), min(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_float4()
         {
             TestUtils.AreEqual(float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, -3456.7f), min(float4(float.NegativeInfinity, float.NegativeInfinity, -1f, -1234.56f), float4(float.NegativeInfinity, -1f, float.NegativeInfinity, -3456.7f)));
@@ -3057,7 +3057,7 @@ public static void min_float4()
             TestUtils.AreEqual(float4(float.PositiveInfinity, 2.3f, 2.3f, TestUtils.SignedFloatQNaN()), min(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), 2.3f, TestUtils.SignedFloatQNaN()), float4(float.PositiveInfinity, 2.3f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_double()
         {
             TestUtils.AreEqual(double.NegativeInfinity, min(double.NegativeInfinity, double.NegativeInfinity));
@@ -3078,7 +3078,7 @@ public static void min_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), min(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_double2()
         {
             TestUtils.AreEqual(double2(double.NegativeInfinity, double.NegativeInfinity), min(double2(double.NegativeInfinity, double.NegativeInfinity), double2(double.NegativeInfinity, -1.0)));
@@ -3091,7 +3091,7 @@ public static void min_double2()
             TestUtils.AreEqual(double2(2.3, TestUtils.SignedDoubleQNaN()), min(double2(2.3, TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_double3()
         {
             TestUtils.AreEqual(double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity), min(double3(double.NegativeInfinity, double.NegativeInfinity, -1.0), double3(double.NegativeInfinity, -1.0, double.NegativeInfinity)));
@@ -3102,7 +3102,7 @@ public static void min_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), min(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void min_double4()
         {
             TestUtils.AreEqual(double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, -3456.7), min(double4(double.NegativeInfinity, double.NegativeInfinity, -1.0, -1234.56), double4(double.NegativeInfinity, -1.0, double.NegativeInfinity, -3456.7)));
@@ -3111,7 +3111,7 @@ public static void min_double4()
             TestUtils.AreEqual(double4(double.PositiveInfinity, 2.3, 2.3, TestUtils.SignedDoubleQNaN()), min(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), 2.3, TestUtils.SignedDoubleQNaN()), double4(double.PositiveInfinity, 2.3, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_int()
         {
             TestUtils.AreEqual(-2147483648, max(-2147483648, -2147483648));
@@ -3129,7 +3129,7 @@ public static void max_int()
             TestUtils.AreEqual(2147483647, max(2147483647, 2147483647));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_int2()
         {
             TestUtils.AreEqual(int2(-2147483648, -1), max(int2(-2147483648, -2147483648), int2(-2147483648, -1)));
@@ -3141,7 +3141,7 @@ public static void max_int2()
             TestUtils.AreEqual(int2(2147483647, 2147483647), max(int2(2147483647, 2147483647), int2(2147483647, 2147483647)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_int3()
         {
             TestUtils.AreEqual(int3(-2147483648, -1, -1), max(int3(-2147483648, -2147483648, -1), int3(-2147483648, -1, -2147483648)));
@@ -3151,7 +3151,7 @@ public static void max_int3()
             TestUtils.AreEqual(int3(2147483647, 2147483647, 2147483647), max(int3(2147483647, 2147483647, 2147483647), int3(2147483647, 2147483647, 2147483647)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_int4()
         {
             TestUtils.AreEqual(int4(-2147483648, -1, -1, -1234), max(int4(-2147483648, -2147483648, -1, -1234), int4(-2147483648, -1, -2147483648, -3456)));
@@ -3160,7 +3160,7 @@ public static void max_int4()
             TestUtils.AreEqual(int4(2147483647, 2147483647, 2147483647, 2147483647), max(int4(2147483647, 2147483647, 2147483647, 2147483647), int4(2147483647, 2147483647, 2147483647, 2147483647)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_uint()
         {
             TestUtils.AreEqual(3456u, max(1234u, 3456u));
@@ -3172,7 +3172,7 @@ public static void max_uint()
             TestUtils.AreEqual(4294967295u, max(4294967295u, 4294967295u));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_uint2()
         {
             TestUtils.AreEqual(uint2(3456u, 3456u), max(uint2(1234u, 3456u), uint2(3456u, 1234u)));
@@ -3181,7 +3181,7 @@ public static void max_uint2()
             TestUtils.AreEqual(uint2(4294967295u, 4294967295u), max(uint2(4294967295u, 4294967295u), uint2(4294967295u, 4294967295u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_uint3()
         {
             TestUtils.AreEqual(uint3(3456u, 3456u, 4294967040u), max(uint3(1234u, 3456u, 4294967040u), uint3(3456u, 1234u, 7u)));
@@ -3189,14 +3189,14 @@ public static void max_uint3()
             TestUtils.AreEqual(uint3(4294967295u, 4294967295u, 4294967295u), max(uint3(4294967295u, 4294967295u, 4294967295u), uint3(4294967295u, 4294967295u, 4294967295u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_uint4()
         {
             TestUtils.AreEqual(uint4(3456u, 3456u, 4294967040u, 4294967040u), max(uint4(1234u, 3456u, 4294967040u, 7u), uint4(3456u, 1234u, 7u, 4294967040u)));
             TestUtils.AreEqual(uint4(4294967295u, 4294967295u, 4294967295u, 4294967295u), max(uint4(1u, 4294967295u, 4294967295u, 4294967295u), uint4(4294967295u, 1u, 4294967295u, 4294967295u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_long()
         {
             TestUtils.AreEqual(-9223372036854775808L, max(-9223372036854775808L, -9223372036854775808L));
@@ -3214,7 +3214,7 @@ public static void max_long()
             TestUtils.AreEqual(9223372036854775807L, max(9223372036854775807L, 9223372036854775807L));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_ulong()
         {
             TestUtils.AreEqual(3456UL, max(1234UL, 3456UL));
@@ -3226,7 +3226,7 @@ public static void max_ulong()
             TestUtils.AreEqual(18446744073709551615UL, max(18446744073709551615UL, 18446744073709551615UL));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_float()
         {
             TestUtils.AreEqual(float.NegativeInfinity, max(float.NegativeInfinity, float.NegativeInfinity));
@@ -3247,7 +3247,7 @@ public static void max_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), max(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_float2()
         {
             TestUtils.AreEqual(float2(float.NegativeInfinity, -1f), max(float2(float.NegativeInfinity, float.NegativeInfinity), float2(float.NegativeInfinity, -1f)));
@@ -3260,7 +3260,7 @@ public static void max_float2()
             TestUtils.AreEqual(float2(2.3f, TestUtils.SignedFloatQNaN()), max(float2(2.3f, TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_float3()
         {
             TestUtils.AreEqual(float3(float.NegativeInfinity, -1f, -1f), max(float3(float.NegativeInfinity, float.NegativeInfinity, -1f), float3(float.NegativeInfinity, -1f, float.NegativeInfinity)));
@@ -3271,7 +3271,7 @@ public static void max_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), max(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_float4()
         {
             TestUtils.AreEqual(float4(float.NegativeInfinity, -1f, -1f, -1234.56f), max(float4(float.NegativeInfinity, float.NegativeInfinity, -1f, -1234.56f), float4(float.NegativeInfinity, -1f, float.NegativeInfinity, -3456.7f)));
@@ -3280,7 +3280,7 @@ public static void max_float4()
             TestUtils.AreEqual(float4(float.PositiveInfinity, 2.3f, 2.3f, TestUtils.SignedFloatQNaN()), max(float4(float.PositiveInfinity, TestUtils.SignedFloatQNaN(), 2.3f, TestUtils.SignedFloatQNaN()), float4(float.PositiveInfinity, 2.3f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_double()
         {
             TestUtils.AreEqual(double.NegativeInfinity, max(double.NegativeInfinity, double.NegativeInfinity));
@@ -3301,7 +3301,7 @@ public static void max_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), max(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_double2()
         {
             TestUtils.AreEqual(double2(double.NegativeInfinity, -1.0), max(double2(double.NegativeInfinity, double.NegativeInfinity), double2(double.NegativeInfinity, -1.0)));
@@ -3314,7 +3314,7 @@ public static void max_double2()
             TestUtils.AreEqual(double2(2.3, TestUtils.SignedDoubleQNaN()), max(double2(2.3, TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_double3()
         {
             TestUtils.AreEqual(double3(double.NegativeInfinity, -1.0, -1.0), max(double3(double.NegativeInfinity, double.NegativeInfinity, -1.0), double3(double.NegativeInfinity, -1.0, double.NegativeInfinity)));
@@ -3325,7 +3325,7 @@ public static void max_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), max(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void max_double4()
         {
             TestUtils.AreEqual(double4(double.NegativeInfinity, -1.0, -1.0, -1234.56), max(double4(double.NegativeInfinity, double.NegativeInfinity, -1.0, -1234.56), double4(double.NegativeInfinity, -1.0, double.NegativeInfinity, -3456.7)));
@@ -3334,7 +3334,7 @@ public static void max_double4()
             TestUtils.AreEqual(double4(double.PositiveInfinity, 2.3, 2.3, TestUtils.SignedDoubleQNaN()), max(double4(double.PositiveInfinity, TestUtils.SignedDoubleQNaN(), 2.3, TestUtils.SignedDoubleQNaN()), double4(double.PositiveInfinity, 2.3, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void smoothstep_float()
         {
             TestUtils.AreEqual(0f, smoothstep(-123.45f, 345.6f, float.NegativeInfinity), 8, false);
@@ -3351,7 +3351,7 @@ public static void smoothstep_float()
             TestUtils.AreEqual(1f, smoothstep(345.6f, -123.45f, TestUtils.SignedFloatQNaN()), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void smoothstep_float2()
         {
             TestUtils.AreEqual(float2(0f, 0f), smoothstep(float2(-123.45f, -123.45f), float2(345.6f, 345.6f), float2(float.NegativeInfinity, -200f)), 8, false);
@@ -3362,7 +3362,7 @@ public static void smoothstep_float2()
             TestUtils.AreEqual(float2(0f, 1f), smoothstep(float2(345.6f, 345.6f), float2(-123.45f, -123.45f), float2(float.PositiveInfinity, TestUtils.SignedFloatQNaN())), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void smoothstep_float3()
         {
             TestUtils.AreEqual(float3(0f, 0f, 0.00724848127f), smoothstep(float3(-123.45f, -123.45f, -123.45f), float3(345.6f, 345.6f, 345.6f), float3(float.NegativeInfinity, -200f, -100f)), 8, false);
@@ -3371,7 +3371,7 @@ public static void smoothstep_float3()
             TestUtils.AreEqual(float3(0f, 0f, 1f), smoothstep(float3(345.6f, 345.6f, 345.6f), float3(-123.45f, -123.45f, -123.45f), float3(400f, float.PositiveInfinity, TestUtils.SignedFloatQNaN())), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void smoothstep_float4()
         {
             TestUtils.AreEqual(float4(0f, 0f, 0.00724848127f, 1f), smoothstep(float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(345.6f, 345.6f, 345.6f, 345.6f), float4(float.NegativeInfinity, -200f, -100f, 400f)), 8, false);
@@ -3379,7 +3379,7 @@ public static void smoothstep_float4()
             TestUtils.AreEqual(float4(0.992751539f, 0f, 0f, 1f), smoothstep(float4(345.6f, 345.6f, 345.6f, 345.6f), float4(-123.45f, -123.45f, -123.45f, -123.45f), float4(-100f, 400f, float.PositiveInfinity, TestUtils.SignedFloatQNaN())), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void smoothstep_double()
         {
             TestUtils.AreEqual(0.0, smoothstep(-123.45, 345.6, double.NegativeInfinity), 8, false);
@@ -3396,7 +3396,7 @@ public static void smoothstep_double()
             TestUtils.AreEqual(1.0, smoothstep(345.6, -123.45, TestUtils.SignedDoubleQNaN()), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void smoothstep_double2()
         {
             TestUtils.AreEqual(double2(0.0, 0.0), smoothstep(double2(-123.45, -123.45), double2(345.6, 345.6), double2(double.NegativeInfinity, -200.0)), 8, false);
@@ -3407,7 +3407,7 @@ public static void smoothstep_double2()
             TestUtils.AreEqual(double2(0.0, 1.0), smoothstep(double2(345.6, 345.6), double2(-123.45, -123.45), double2(double.PositiveInfinity, TestUtils.SignedDoubleQNaN())), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void smoothstep_double3()
         {
             TestUtils.AreEqual(double3(0.0, 0.0, 0.0072484810488798995), smoothstep(double3(-123.45, -123.45, -123.45), double3(345.6, 345.6, 345.6), double3(double.NegativeInfinity, -200.0, -100.0)), 8, false);
@@ -3416,7 +3416,7 @@ public static void smoothstep_double3()
             TestUtils.AreEqual(double3(0.0, 0.0, 1.0), smoothstep(double3(345.6, 345.6, 345.6), double3(-123.45, -123.45, -123.45), double3(400.0, double.PositiveInfinity, TestUtils.SignedDoubleQNaN())), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void smoothstep_double4()
         {
             TestUtils.AreEqual(double4(0.0, 0.0, 0.0072484810488798995, 1.0), smoothstep(double4(-123.45, -123.45, -123.45, -123.45), double4(345.6, 345.6, 345.6, 345.6), double4(double.NegativeInfinity, -200.0, -100.0, 400.0)), 8, false);
@@ -3424,7 +3424,7 @@ public static void smoothstep_double4()
             TestUtils.AreEqual(double4(0.99275151895112013, 0.0, 0.0, 1.0), smoothstep(double4(345.6, 345.6, 345.6, 345.6), double4(-123.45, -123.45, -123.45, -123.45), double4(-100.0, 400.0, double.PositiveInfinity, TestUtils.SignedDoubleQNaN())), 8, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_int()
         {
             TestUtils.AreEqual(7097663, mad(1234, 5678, 91011));
@@ -3445,7 +3445,7 @@ public static void mad_int()
             TestUtils.AreEqual(1313707278, mad(-98765, -56789, -91011));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_int2()
         {
             TestUtils.AreEqual(int2(7097663, 6915641), mad(int2(1234, 1234), int2(5678, 5678), int2(91011, -91011)));
@@ -3458,7 +3458,7 @@ public static void mad_int2()
             TestUtils.AreEqual(int2(1313889300, 1313707278), mad(int2(-98765, -98765), int2(-56789, -56789), int2(91011, -91011)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_int3()
         {
             TestUtils.AreEqual(int3(7097663, 6915641, -6915641), mad(int3(1234, 1234, 1234), int3(5678, 5678, -5678), int3(91011, -91011, 91011)));
@@ -3469,7 +3469,7 @@ public static void mad_int3()
             TestUtils.AreEqual(int3(1313707278, 1313707278, 1313707278), mad(int3(-98765, -98765, -98765), int3(-56789, -56789, -56789), int3(-91011, -91011, -91011)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_int4()
         {
             TestUtils.AreEqual(int4(7097663, 6915641, -6915641, -7097663), mad(int4(1234, 1234, 1234, 1234), int4(5678, 5678, -5678, -5678), int4(91011, -91011, 91011, -91011)));
@@ -3478,32 +3478,32 @@ public static void mad_int4()
             TestUtils.AreEqual(int4(-1313707278, -1313889300, 1313889300, 1313707278), mad(int4(-98765, -98765, -98765, -98765), int4(56789, 56789, -56789, -56789), int4(91011, -91011, 91011, -91011)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_uint()
         {
             TestUtils.AreEqual(7097663u, mad(1234u, 5678u, 91011u));
             TestUtils.AreEqual(1313889300u, mad(98765u, 56789u, 91011u));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_uint2()
         {
             TestUtils.AreEqual(uint2(7097663u, 1313889300u), mad(uint2(1234u, 98765u), uint2(5678u, 56789u), uint2(91011u, 91011u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_uint3()
         {
             TestUtils.AreEqual(uint3(7097663u, 1313889300u, 1313889300u), mad(uint3(1234u, 98765u, 98765u), uint3(5678u, 56789u, 56789u), uint3(91011u, 91011u, 91011u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_uint4()
         {
             TestUtils.AreEqual(uint4(7097663u, 1313889300u, 1313889300u, 1313889300u), mad(uint4(1234u, 98765u, 98765u, 98765u), uint4(5678u, 56789u, 56789u, 56789u), uint4(91011u, 91011u, 91011u, 91011u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_long()
         {
             TestUtils.AreEqual(7097663L, mad(1234L, 5678L, 91011L));
@@ -3524,14 +3524,14 @@ public static void mad_long()
             TestUtils.AreEqual(747681192693554158L, mad(-9876543210L, -5678901234L, -9101112134L));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_ulong()
         {
             TestUtils.AreEqual(7097663L, mad(1234UL, 5678UL, 91011UL));
             TestUtils.AreEqual(747681210895778426L, mad(9876543210UL, 5678901234UL, 9101112134UL));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_float()
         {
             TestUtils.AreEqual(-42660f, mad(-123.45f, 345.6f, 4.321f), 1, false);
@@ -3540,27 +3540,27 @@ public static void mad_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), mad(-123.45f, 345.6f, TestUtils.SignedFloatQNaN()), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_float2()
         {
             TestUtils.AreEqual(float2(-42660f, TestUtils.SignedFloatQNaN()), mad(float2(-123.45f, TestUtils.SignedFloatQNaN()), float2(345.6f, 345.6f), float2(4.321f, 4.321f)), 1, false);
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), mad(float2(-123.45f, -123.45f), float2(TestUtils.SignedFloatQNaN(), 345.6f), float2(4.321f, TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_float3()
         {
             TestUtils.AreEqual(float3(-42660f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), mad(float3(-123.45f, TestUtils.SignedFloatQNaN(), -123.45f), float3(345.6f, 345.6f, TestUtils.SignedFloatQNaN()), float3(4.321f, 4.321f, 4.321f)), 1, false);
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), mad(float3(-123.45f, -123.45f, -123.45f), float3(345.6f, 345.6f, 345.6f), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_float4()
         {
             TestUtils.AreEqual(float4(-42660f, TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), mad(float4(-123.45f, TestUtils.SignedFloatQNaN(), -123.45f, -123.45f), float4(345.6f, 345.6f, TestUtils.SignedFloatQNaN(), 345.6f), float4(4.321f, 4.321f, 4.321f, TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_double()
         {
             TestUtils.AreEqual(-42659.999, mad(-123.45, 345.6, 4.321), 1, false);
@@ -3569,27 +3569,27 @@ public static void mad_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), mad(-123.45, 345.6, TestUtils.SignedDoubleQNaN()), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_double2()
         {
             TestUtils.AreEqual(double2(-42659.999, TestUtils.SignedDoubleQNaN()), mad(double2(-123.45, TestUtils.SignedDoubleQNaN()), double2(345.6, 345.6), double2(4.321, 4.321)), 1, false);
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), mad(double2(-123.45, -123.45), double2(TestUtils.SignedDoubleQNaN(), 345.6), double2(4.321, TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_double3()
         {
             TestUtils.AreEqual(double3(-42659.999, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), mad(double3(-123.45, TestUtils.SignedDoubleQNaN(), -123.45), double3(345.6, 345.6, TestUtils.SignedDoubleQNaN()), double3(4.321, 4.321, 4.321)), 1, false);
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), mad(double3(-123.45, -123.45, -123.45), double3(345.6, 345.6, 345.6), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void mad_double4()
         {
             TestUtils.AreEqual(double4(-42659.999, TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), mad(double4(-123.45, TestUtils.SignedDoubleQNaN(), -123.45, -123.45), double4(345.6, 345.6, TestUtils.SignedDoubleQNaN(), 345.6), double4(4.321, 4.321, 4.321, TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void fmod_float()
         {
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), fmod(float.NegativeInfinity, float.NegativeInfinity), 1, false);
@@ -3643,7 +3643,7 @@ public static void fmod_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), fmod(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void fmod_float2()
         {
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), -323.4f), fmod(float2(float.NegativeInfinity, -323.4f), float2(float.NegativeInfinity, float.NegativeInfinity)), 1, false);
@@ -3673,7 +3673,7 @@ public static void fmod_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), fmod(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void fmod_float3()
         {
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), -323.4f, TestUtils.SignedFloatZero()), fmod(float3(float.NegativeInfinity, -323.4f, TestUtils.SignedFloatZero()), float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), 1, false);
@@ -3695,7 +3695,7 @@ public static void fmod_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), fmod(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void fmod_float4()
         {
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), -323.4f, TestUtils.SignedFloatZero(), 0f), fmod(float4(float.NegativeInfinity, -323.4f, TestUtils.SignedFloatZero(), 0f), float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), 1, false);
@@ -3713,7 +3713,7 @@ public static void fmod_float4()
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), fmod(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void fmod_double()
         {
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), fmod(double.NegativeInfinity, double.NegativeInfinity), 1, false);
@@ -3767,7 +3767,7 @@ public static void fmod_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), fmod(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void fmod_double2()
         {
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), -323.4), fmod(double2(double.NegativeInfinity, -323.4), double2(double.NegativeInfinity, double.NegativeInfinity)), 1, false);
@@ -3797,7 +3797,7 @@ public static void fmod_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), fmod(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void fmod_double3()
         {
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), -323.4, TestUtils.SignedDoubleZero()), fmod(double3(double.NegativeInfinity, -323.4, TestUtils.SignedDoubleZero()), double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), 1, false);
@@ -3819,7 +3819,7 @@ public static void fmod_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), fmod(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void fmod_double4()
         {
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), -323.4, TestUtils.SignedDoubleZero(), 0.0), fmod(double4(double.NegativeInfinity, -323.4, TestUtils.SignedDoubleZero(), 0.0), double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), 1, false);
@@ -3837,7 +3837,7 @@ public static void fmod_double4()
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), fmod(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void pow_float()
         {
             TestUtils.AreEqual(0f, pow(float.NegativeInfinity, float.NegativeInfinity), 1, false);
@@ -3887,7 +3887,7 @@ public static void pow_float()
             TestUtils.AreEqual(TestUtils.SignedFloatQNaN(), pow(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void pow_float2()
         {
             TestUtils.AreEqual(float2(0f, 0f), pow(float2(float.NegativeInfinity, -3.4f), float2(float.NegativeInfinity, float.NegativeInfinity)), 1, false);
@@ -3915,7 +3915,7 @@ public static void pow_float2()
             TestUtils.AreEqual(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), pow(float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float2(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void pow_float3()
         {
             TestUtils.AreEqual(float3(0f, 0f, float.PositiveInfinity), pow(float3(float.NegativeInfinity, -3.4f, TestUtils.SignedFloatZero()), float3(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), 1, false);
@@ -3935,7 +3935,7 @@ public static void pow_float3()
             TestUtils.AreEqual(float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), pow(float3(3.4f, float.PositiveInfinity, TestUtils.SignedFloatQNaN()), float3(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void pow_float4()
         {
             TestUtils.AreEqual(float4(0f, 0f, float.PositiveInfinity, float.PositiveInfinity), pow(float4(float.NegativeInfinity, -3.4f, TestUtils.SignedFloatZero(), 0f), float4(float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity, float.NegativeInfinity)), 1, false);
@@ -3952,7 +3952,7 @@ public static void pow_float4()
             TestUtils.AreEqual(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), pow(float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN()), float4(TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN(), TestUtils.SignedFloatQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void pow_double()
         {
             TestUtils.AreEqual(0.0, pow(double.NegativeInfinity, double.NegativeInfinity), 1, false);
@@ -4002,7 +4002,7 @@ public static void pow_double()
             TestUtils.AreEqual(TestUtils.SignedDoubleQNaN(), pow(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void pow_double2()
         {
             TestUtils.AreEqual(double2(0.0, 0.0), pow(double2(double.NegativeInfinity, -3.4), double2(double.NegativeInfinity, double.NegativeInfinity)), 1, false);
@@ -4030,7 +4030,7 @@ public static void pow_double2()
             TestUtils.AreEqual(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), pow(double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double2(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void pow_double3()
         {
             TestUtils.AreEqual(double3(0.0, 0.0, double.PositiveInfinity), pow(double3(double.NegativeInfinity, -3.4, TestUtils.SignedDoubleZero()), double3(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), 1, false);
@@ -4050,7 +4050,7 @@ public static void pow_double3()
             TestUtils.AreEqual(double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), pow(double3(3.4, double.PositiveInfinity, TestUtils.SignedDoubleQNaN()), double3(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void pow_double4()
         {
             TestUtils.AreEqual(double4(0.0, 0.0, double.PositiveInfinity, double.PositiveInfinity), pow(double4(double.NegativeInfinity, -3.4, TestUtils.SignedDoubleZero(), 0.0), double4(double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity, double.NegativeInfinity)), 1, false);
@@ -4067,7 +4067,7 @@ public static void pow_double4()
             TestUtils.AreEqual(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), pow(double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN()), double4(TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN(), TestUtils.SignedDoubleQNaN())), 1, false);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceilpow2_int()
         {
             TestUtils.AreEqual(0, ceilpow2(0));
@@ -4079,7 +4079,7 @@ public static void ceilpow2_int()
             TestUtils.AreEqual(0, ceilpow2(-2147483647));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceilpow2_int2()
         {
             TestUtils.AreEqual(int2(0, 1), ceilpow2(int2(0, 1)));
@@ -4088,7 +4088,7 @@ public static void ceilpow2_int2()
             TestUtils.AreEqual(int2(0, 0), ceilpow2(int2(-2147483647, -2147483647)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceilpow2_int3()
         {
             TestUtils.AreEqual(int3(0, 1, 2), ceilpow2(int3(0, 1, 2)));
@@ -4096,14 +4096,14 @@ public static void ceilpow2_int3()
             TestUtils.AreEqual(int3(0, 0, 0), ceilpow2(int3(-2147483647, -2147483647, -2147483647)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceilpow2_int4()
         {
             TestUtils.AreEqual(int4(0, 1, 2, 4), ceilpow2(int4(0, 1, 2, 3)));
             TestUtils.AreEqual(int4(1073741824, -2147483648, 0, 0), ceilpow2(int4(1019642234, 1823423423, -2147483647, -2147483647)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceilpow2_uint()
         {
             TestUtils.AreEqual(0u, ceilpow2(0u));
@@ -4115,7 +4115,7 @@ public static void ceilpow2_uint()
             TestUtils.AreEqual(0u, ceilpow2(4294967295u));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceilpow2_uint2()
         {
             TestUtils.AreEqual(uint2(0u, 1u), ceilpow2(uint2(0u, 1u)));
@@ -4124,7 +4124,7 @@ public static void ceilpow2_uint2()
             TestUtils.AreEqual(uint2(0u, 0u), ceilpow2(uint2(4294967295u, 4294967295u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceilpow2_uint3()
         {
             TestUtils.AreEqual(uint3(0u, 1u, 2u), ceilpow2(uint3(0u, 1u, 2u)));
@@ -4132,14 +4132,14 @@ public static void ceilpow2_uint3()
             TestUtils.AreEqual(uint3(0u, 0u, 0u), ceilpow2(uint3(4294967295u, 4294967295u, 4294967295u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceilpow2_uint4()
         {
             TestUtils.AreEqual(uint4(0u, 1u, 2u, 4u), ceilpow2(uint4(0u, 1u, 2u, 3u)));
             TestUtils.AreEqual(uint4(1073741824u, 2147483648u, 0u, 0u), ceilpow2(uint4(1019642234u, 1823423423u, 4294967295u, 4294967295u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceilpow2_long()
         {
             TestUtils.AreEqual(0L, ceilpow2(0L));
@@ -4155,7 +4155,7 @@ public static void ceilpow2_long()
             TestUtils.AreEqual(0L, ceilpow2(-100L));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceilpow2_ulong()
         {
             TestUtils.AreEqual(0UL, ceilpow2(0UL));
@@ -4171,7 +4171,7 @@ public static void ceilpow2_ulong()
             TestUtils.AreEqual(0UL, ceilpow2(10223372036854775808UL));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void floorlog2_int()
         {
             TestUtils.AreEqual(0, floorlog2(1));
@@ -4185,7 +4185,7 @@ public static void floorlog2_int()
             TestUtils.AreEqual(30, floorlog2(2147483647));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void floorlog2_int2()
         {
             TestUtils.AreEqual(int2(0, 1), floorlog2(int2(1, 2)));
@@ -4195,7 +4195,7 @@ public static void floorlog2_int2()
             TestUtils.AreEqual(int2(30, 30), floorlog2(int2(2147483647, 2147483647)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void floorlog2_int3()
         {
             TestUtils.AreEqual(int3(0, 1, 1), floorlog2(int3(1, 2, 3)));
@@ -4203,7 +4203,7 @@ public static void floorlog2_int3()
             TestUtils.AreEqual(int3(15, 15, 30), floorlog2(int3(32768, 32769, 2147483647)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void floorlog2_int4()
         {
             TestUtils.AreEqual(int4(0, 1, 1, 2), floorlog2(int4(1, 2, 3, 4)));
@@ -4211,7 +4211,7 @@ public static void floorlog2_int4()
             TestUtils.AreEqual(int4(30, 30, 30, 30), floorlog2(int4(2147483647, 2147483647, 2147483647, 2147483647)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void floorlog2_uint()
         {
             TestUtils.AreEqual(0, floorlog2(1u));
@@ -4225,7 +4225,7 @@ public static void floorlog2_uint()
             TestUtils.AreEqual(30, floorlog2(2147483647u));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void floorlog2_uint2()
         {
             TestUtils.AreEqual(int2(0, 1), floorlog2(uint2(1u, 2u)));
@@ -4235,7 +4235,7 @@ public static void floorlog2_uint2()
             TestUtils.AreEqual(int2(30, 30), floorlog2(uint2(2147483647u, 2147483647u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void floorlog2_uint3()
         {
             TestUtils.AreEqual(int3(0, 1, 1), floorlog2(uint3(1u, 2u, 3u)));
@@ -4243,7 +4243,7 @@ public static void floorlog2_uint3()
             TestUtils.AreEqual(int3(15, 15, 30), floorlog2(uint3(32768u, 32769u, 2147483647u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void floorlog2_uint4()
         {
             TestUtils.AreEqual(int4(0, 1, 1, 2), floorlog2(uint4(1u, 2u, 3u, 4u)));
@@ -4251,7 +4251,7 @@ public static void floorlog2_uint4()
             TestUtils.AreEqual(int4(30, 30, 30, 30), floorlog2(uint4(2147483647u, 2147483647u, 2147483647u, 2147483647u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceillog2_int()
         {
             TestUtils.AreEqual(0, ceillog2(1));
@@ -4269,7 +4269,7 @@ public static void ceillog2_int()
             TestUtils.AreEqual(31, ceillog2(2147483647));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceillog2_int2()
         {
             TestUtils.AreEqual(int2(0, 1), ceillog2(int2(1, 2)));
@@ -4281,7 +4281,7 @@ public static void ceillog2_int2()
             TestUtils.AreEqual(int2(31, 31), ceillog2(int2(2147483647, 2147483647)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceillog2_int3()
         {
             TestUtils.AreEqual(int3(0, 1, 2), ceillog2(int3(1, 2, 3)));
@@ -4291,7 +4291,7 @@ public static void ceillog2_int3()
             TestUtils.AreEqual(int3(31, 31, 31), ceillog2(int3(2147483647, 2147483647, 2147483647)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceillog2_int4()
         {
             TestUtils.AreEqual(int4(0, 1, 2, 2), ceillog2(int4(1, 2, 3, 4)));
@@ -4300,7 +4300,7 @@ public static void ceillog2_int4()
             TestUtils.AreEqual(int4(31, 31, 31, 31), ceillog2(int4(2147483647, 2147483647, 2147483647, 2147483647)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceillog2_uint()
         {
             TestUtils.AreEqual(0, ceillog2(1u));
@@ -4318,7 +4318,7 @@ public static void ceillog2_uint()
             TestUtils.AreEqual(32, ceillog2(4294967295u));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceillog2_uint2()
         {
             TestUtils.AreEqual(int2(0, 1), ceillog2(uint2(1u, 2u)));
@@ -4330,7 +4330,7 @@ public static void ceillog2_uint2()
             TestUtils.AreEqual(int2(32, 32), ceillog2(uint2(4294967295u, 4294967295u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceillog2_uint3()
         {
             TestUtils.AreEqual(int3(0, 1, 2), ceillog2(uint3(1u, 2u, 3u)));
@@ -4340,7 +4340,7 @@ public static void ceillog2_uint3()
             TestUtils.AreEqual(int3(32, 32, 32), ceillog2(uint3(4294967295u, 4294967295u, 4294967295u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ceillog2_uint4()
         {
             TestUtils.AreEqual(int4(0, 1, 2, 2), ceillog2(uint4(1u, 2u, 3u, 4u)));
@@ -4349,7 +4349,7 @@ public static void ceillog2_uint4()
             TestUtils.AreEqual(int4(32, 32, 32, 32), ceillog2(uint4(4294967295u, 4294967295u, 4294967295u, 4294967295u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ispow2_int()
         {
             TestUtils.AreEqual(false, ispow2(-3));
@@ -4368,7 +4368,7 @@ public static void ispow2_int()
             TestUtils.AreEqual(false, ispow2(268431360));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ispow2_int2()
         {
             TestUtils.AreEqual(bool2(false, false), ispow2(int2(-3, -2)));
@@ -4380,7 +4380,7 @@ public static void ispow2_int2()
             TestUtils.AreEqual(bool2(true, false), ispow2(int2(2097152, 268431360)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ispow2_int3()
         {
             TestUtils.AreEqual(bool3(false, false, false), ispow2(int3(-3, -2, -1)));
@@ -4390,7 +4390,7 @@ public static void ispow2_int3()
             TestUtils.AreEqual(bool3(true, false, false), ispow2(int3(2097152, 268431360, 268431360)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ispow2_int4()
         {
             TestUtils.AreEqual(bool4(false, false, false, false), ispow2(int4(-3, -2, -1, 0)));
@@ -4399,7 +4399,7 @@ public static void ispow2_int4()
             TestUtils.AreEqual(bool4(true, false, false, false), ispow2(int4(2097152, 268431360, 268431360, 268431360)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ispow2_uint()
         {
             TestUtils.AreEqual(false, ispow2(0u));
@@ -4416,7 +4416,7 @@ public static void ispow2_uint()
             TestUtils.AreEqual(false, ispow2(268431360u));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ispow2_uint2()
         {
             TestUtils.AreEqual(bool2(false, true), ispow2(uint2(0u, 1u)));
@@ -4427,7 +4427,7 @@ public static void ispow2_uint2()
             TestUtils.AreEqual(bool2(false, false), ispow2(uint2(2097153u, 268431360u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ispow2_uint3()
         {
             TestUtils.AreEqual(bool3(false, true, true), ispow2(uint3(0u, 1u, 2u)));
@@ -4436,7 +4436,7 @@ public static void ispow2_uint3()
             TestUtils.AreEqual(bool3(true, false, false), ispow2(uint3(2097152u, 2097153u, 268431360u)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ispow2_uint4()
         {
             TestUtils.AreEqual(bool4(false, true, true, false), ispow2(uint4(0u, 1u, 2u, 3u)));
diff --git a/src/Tests/Tests/Shared/TestMatrix.cs b/src/Tests/Tests/Shared/TestMatrix.cs
index 5fc6a37b..558ce482 100644
--- a/src/Tests/Tests/Shared/TestMatrix.cs
+++ b/src/Tests/Tests/Shared/TestMatrix.cs
@@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     class TestMatrix
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_constructor_columns()
         {
             float2x2 a = float2x2(float2(1.0f, 2.0f),
@@ -19,7 +19,7 @@ public static void float2x2_constructor_columns()
             TestUtils.AreEqual(4.0f, a.c1.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_constructor_columns()
         {
             float3x3 a = float3x3(float3(1.0f, 2.0f, 3.0f),
@@ -37,7 +37,7 @@ public static void float3x3_constructor_columns()
             TestUtils.AreEqual(9.0f, a.c2.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_constructor_columns()
         {
             float4x4 a = float4x4(float4( 1.0f,  2.0f,  3.0f,  4.0f),
@@ -63,7 +63,7 @@ public static void float4x4_constructor_columns()
             TestUtils.AreEqual(16.0f, a.c3.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_constructor_scalars()
         {
             float2x2 a = float2x2(1.0f, 2.0f,
@@ -75,7 +75,7 @@ public static void float2x2_constructor_scalars()
             TestUtils.AreEqual(4.0f, a.c1.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_constructor_scalars()
         {
             float3x3 a = float3x3(1.0f, 2.0f, 3.0f,
@@ -93,7 +93,7 @@ public static void float3x3_constructor_scalars()
             TestUtils.AreEqual(9.0f, a.c2.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_constructor_scalars()
         {
             float4x4 a = float4x4( 1.0f,  2.0f,  3.0f,  4.0f,
@@ -119,7 +119,7 @@ public static void float4x4_constructor_scalars()
             TestUtils.AreEqual(16.0f, a.c3.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_constructor_float3x3()
         {
             float3x3 rot = float3x3(1.0f, 2.0f, 3.0f,
@@ -136,7 +136,7 @@ public static void float4x4_constructor_float3x3()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_constructor_quaternion()
         {
             float3x3 m = float3x3(normalize(quaternion(1.0f, 2.5f, 3.3f, 4.6f)));
@@ -148,7 +148,7 @@ public static void float3x3_constructor_quaternion()
             TestUtils.AreEqual(r, m, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_constructor_quaternion_position()
         {
             float4x4 m = float4x4(normalize(quaternion(1.0f, 2.5f, 3.3f, 4.6f)), float3(1.0f, 2.0f, 3.0f));
@@ -161,7 +161,7 @@ public static void float4x4_constructor_quaternion_position()
             TestUtils.AreEqual(r, m, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_identity()
         {
             float2x2 a = float2x2.identity;
@@ -171,7 +171,7 @@ public static void float2x2_identity()
             TestUtils.AreEqual(1.0f, a.c1.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_identity()
         {
             float3x3 a = float3x3.identity;
@@ -186,7 +186,7 @@ public static void float3x3_identity()
             TestUtils.AreEqual(1.0f, a.c2.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_identity()
         {
             float4x4 a = float4x4.identity;
@@ -208,7 +208,7 @@ public static void float4x4_identity()
             TestUtils.AreEqual(1.0f, a.c3.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_rotate()
         {
             float epsilon = 0.0001f;
@@ -220,7 +220,7 @@ public static void float2x2_rotate()
             TestUtils.AreEqual(cos(angle), m.c1.y, epsilon);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_axis_angle()
         {
             float3 axis = normalize(float3(1.1f, 2.3f, -3.6f));
@@ -231,7 +231,7 @@ public static void float3x3_axis_angle()
             TestUtils.AreEqual(r, m, 0.00001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_axis_angle_consistency()
         {
             TestUtils.AreEqual(float3x3.RotateX(1.0f), float3x3.AxisAngle(float3(1, 0, 0), 1.0f), 0.001f);
@@ -239,7 +239,7 @@ public static void float3x3_axis_angle_consistency()
             TestUtils.AreEqual(float3x3.RotateZ(1.0f), float3x3.AxisAngle(float3(0, 0, 1), 1.0f), 0.001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_rotate_x()
         {
             float epsilon = 0.0001f;
@@ -256,7 +256,7 @@ public static void float3x3_rotate_x()
             TestUtils.AreEqual(cos(angle), m.c2.z, epsilon);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_rotate_y()
         {
             float epsilon = 0.0001f;
@@ -273,7 +273,7 @@ public static void float3x3_rotate_y()
             TestUtils.AreEqual(cos(angle), m.c2.z, epsilon);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_rotate_z()
         {
             float epsilon = 0.0001f;
@@ -290,7 +290,7 @@ public static void float3x3_rotate_z()
             TestUtils.AreEqual(1.0f, m.c2.z, epsilon);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_rotate_x_handedness()
         {
             float3 a = float3(0.0f, 0.3f, 0.7f);
@@ -301,7 +301,7 @@ public static void float3x3_rotate_x_handedness()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_rotate_y_handedness()
         {
             float3 a = float3(0.3f, 0.0f, 0.7f);
@@ -311,7 +311,7 @@ public static void float3x3_rotate_y_handedness()
             TestUtils.AreEqual(w > 0.0f, true);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_rotate_z_handedness()
         {
             float3 a = float3(0.3f, 0.7f, 0.0f);
@@ -321,7 +321,7 @@ public static void float3x3_rotate_z_handedness()
             TestUtils.AreEqual(w > 0.0f, true);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_axis_angle()
         {
             float3 axis = normalize(float3(1.1f, 2.3f, -3.6f));
@@ -332,7 +332,7 @@ public static void float4x4_axis_angle()
             TestUtils.AreEqual(r, m, 0.00001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_axis_angle_consistency()
         {
             TestUtils.AreEqual(float4x4.RotateX(1.0f), float4x4.AxisAngle(float3(1, 0, 0), 1.0f), 0.001f);
@@ -340,7 +340,7 @@ public static void float4x4_axis_angle_consistency()
             TestUtils.AreEqual(float4x4.RotateZ(1.0f), float4x4.AxisAngle(float3(0, 0, 1), 1.0f), 0.001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_rotate_x()
         {
             float epsilon = 0.0001f;
@@ -364,7 +364,7 @@ public static void float4x4_rotate_x()
             TestUtils.AreEqual(1.0f, m.c3.w, epsilon);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_rotate_y()
         {
             float epsilon = 0.0001f;
@@ -388,7 +388,7 @@ public static void float4x4_rotate_y()
             TestUtils.AreEqual(1.0f, m.c3.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_rotate_z()
         {
             float epsilon = 0.0001f;
@@ -412,7 +412,7 @@ public static void float4x4_rotate_z()
             TestUtils.AreEqual(1.0f, m.c3.w, epsilon);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_rotate_x_handedness()
         {
             float3 a = float3(0.0f, 0.3f, 0.7f);
@@ -423,7 +423,7 @@ public static void float4x4_rotate_x_handedness()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_rotate_y_handedness()
         {
             float3 a = float3(0.3f, 0.0f, 0.7f);
@@ -433,7 +433,7 @@ public static void float4x4_rotate_y_handedness()
             TestUtils.AreEqual(w > 0.0f, true);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_rotate_z_handedness()
         {
             float3 a = float3(0.3f, 0.7f, 0.0f);
@@ -480,7 +480,7 @@ public static void float4x4_rotate_z_handedness()
         static internal readonly float4x4 test4x4_zyx = new float4x4(test3x3_zyx, new float3(0, 0, 0));
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_euler()
         {
             float3x3 m0_xyz = float3x3.EulerXYZ(test_angles);
@@ -547,7 +547,7 @@ public static void float3x3_euler()
             TestUtils.AreEqual(test3x3_zyx, m3_zyx, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_euler()
         {
             float4x4 m0_xyz = float4x4.EulerXYZ(test_angles);
@@ -614,7 +614,7 @@ public static void float4x4_euler()
             TestUtils.AreEqual(test4x4_zyx, m3_zyx, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_scale()
         {
             float2x2 m = float2x2(1.0f, 2.0f,
@@ -635,7 +635,7 @@ public static void float2x2_scale()
             TestUtils.AreEqual(r1, c);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_scale()
         {
             float3x3 m = float3x3(1.0f, 2.0f, 3.0f,
@@ -661,7 +661,7 @@ public static void float3x3_scale()
             TestUtils.AreEqual(r1, c);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_scale()
         {
             float4x4 m = float4x4( 1.0f,  2.0f,  3.0f,  4.0f,
@@ -688,7 +688,7 @@ public static void float4x4_scale()
             TestUtils.AreEqual(r1, c);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_matrix_mul()
         {
             // http://www.wolframalpha.com/input/?i=%5B%5B1,2%5D,%5B3,4%5D%5D*%5B%5B21,22%5D,%5B23,24%5D%5D
@@ -706,7 +706,7 @@ public static void float2x2_matrix_mul()
             TestUtils.AreEqual(162.0f, c.c1.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_matrix_mul()
         {
             // http://www.wolframalpha.com/input/?i=%5B%5B1,2,3%5D,%5B4,5,6%5D,%5B7,8,9%5D%5D*%5B%5B21,22,23%5D,%5B24,25,26%5D,%5B27,28,29%5D%5D
@@ -732,7 +732,7 @@ public static void float3x3_matrix_mul()
             TestUtils.AreEqual(630.0f, c.c2.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_matrix_mul()
         {
             // https://fogbugz.unity3d.com/f/cases/1041176/
@@ -769,7 +769,7 @@ public static void float4x4_matrix_mul()
             TestUtils.AreEqual(1760.0f, c.c3.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_transpose()
         {
             float2x2 a = float2x2(1.0f, 2.0f,
@@ -783,7 +783,7 @@ public static void float2x2_transpose()
             TestUtils.AreEqual(4.0f, b.c1.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_transpose()
         {
             float3x3 a = float3x3(1.0f, 2.0f, 3.0f,
@@ -803,7 +803,7 @@ public static void float3x3_transpose()
             TestUtils.AreEqual(9.0f, b.c2.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_transpose()
         {
             float4x4 a = float4x4( 1.0f,  2.0f,  3.0f,  4.0f,
@@ -831,7 +831,7 @@ public static void float4x4_transpose()
             TestUtils.AreEqual(16.0f, b.c3.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_inverse()
         {
             float2x2 a = float2x2( 0.542968f,  0.867379f,
@@ -850,7 +850,7 @@ public static void float2x2_inverse()
             TestUtils.AreEqual(r.c1.y, invA.c1.y, epsilon);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_inverse()
         {
             float3x3 a = float3x3( 0.542968f, 0.867379f, 0.526616f,
@@ -877,7 +877,7 @@ public static void float3x3_inverse()
             TestUtils.AreEqual(r.c2.z, invA.c2.z, epsilon);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_inverse()
         {
             float4x4 a = float4x4( 0.542968f, 0.867379f, 0.526616f,-0.943083f,
@@ -914,7 +914,7 @@ public static void float4x4_inverse()
             TestUtils.AreEqual(r.c3.w, invA.c3.w, epsilon);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x4_fastinverse()
         {
             float4x4 a = test4x4_xyz;
@@ -931,7 +931,7 @@ public static void float3x4_fastinverse()
             TestUtils.AreEqual(invA.c3.xyz, fastInvB.c3.xyz, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_fastinverse()
         {
             float4x4 a = test4x4_xyz;
@@ -943,7 +943,7 @@ public static void float4x4_fastinverse()
             TestUtils.AreEqual(invA, fastInvA, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2x2_determinant()
         {
             float2x2 a = float2x2(0.542968f, 0.867379f,
@@ -953,7 +953,7 @@ public static void float2x2_determinant()
             TestUtils.AreEqual(-0.2610378f, det, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_determinant()
         {
             float3x3 a = float3x3( 0.542968f,  0.867379f, 0.526616f,
@@ -964,7 +964,7 @@ public static void float3x3_determinant()
             TestUtils.AreEqual(0.06019618f, det, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_determinant()
         {
             float4x4 a = float4x4( 0.542968f,  0.867379f, 0.526616f, -0.943083f,
@@ -976,7 +976,7 @@ public static void float4x4_determinant()
             TestUtils.AreEqual(0.5838502f, det, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_look_rotation()
         {
             float3 forward0 = normalize(float3(1.0f, 2.0f, 3.0f));
@@ -1012,7 +1012,7 @@ public static void float3x3_look_rotation()
             TestUtils.AreEqual(float3x3(quaternion.LookRotation(forward3, up3)), m3, 0.001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_look_rotation_safe()
         {
             float3 forward0 = float3(-3.2f, 2.3f, -1.3f) * 1e-10f;
@@ -1029,7 +1029,7 @@ public static void float3x3_look_rotation_safe()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_lookat()
         {
             float4x4 m = float4x4.LookAt(float3(0.3f, -0.5f, 3.0f), float3(3.2f, -3.1f, 0.2f), normalize(float3(0.3f, 1.0f, -3.0f)));
@@ -1043,7 +1043,7 @@ public static void float4x4_lookat()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_ortho()
         {
             float4x4 m = float4x4.Ortho(2.0f, 3.0f, -3.0f, 7.0f);
@@ -1056,7 +1056,7 @@ public static void float4x4_ortho()
             TestUtils.AreEqual(r, m, 0.001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_orthoOffCenter()
         {
             float4x4 m = float4x4.OrthoOffCenter(-2.0f, 1.0f, -3.0f, -1.0f, -3.0f, 7.0f);
@@ -1069,7 +1069,7 @@ public static void float4x4_orthoOffCenter()
             TestUtils.AreEqual(r, m, 0.001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_perspective()
         {
             float fovy = 1.6f;
@@ -1098,7 +1098,7 @@ public static void float4x4_perspective()
             TestUtils.AreEqual(float3(1.0f, 1.0f, 1.0f), pp1.xyz, 0.001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_perspectiveOffCenter()
         {
             float fovy = 1.6f;
@@ -1132,7 +1132,7 @@ public static void float4x4_perspectiveOffCenter()
             TestUtils.AreEqual(float3(-1.0f,  1.0f, 1.0f), pp2.xyz, 0.001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4x4_TRS()
         {
             float3 scale = float3(1.2f, -0.4f, 2.3f);
@@ -1143,7 +1143,7 @@ public static void float4x4_TRS()
             TestUtils.AreEqual(r0, m0, 0.001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_constructor_float4x4()
         {
             var f4x4 = new float4x4(new float4(1, 2, 3, 4), new float4(5, 6, 7, 8), new float4(9, 10, 11, 12), new float4(13, 14, 15, 16));
@@ -1152,7 +1152,7 @@ public static void float3x3_constructor_float4x4()
             TestUtils.AreEqual(expected, new float3x3(f4x4));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_explicit_cast_float4x4()
         {
             var f4x4 = new float4x4(new float4(1, 2, 3, 4), new float4(5, 6, 7, 8), new float4(9, 10, 11, 12), new float4(13, 14, 15, 16));
@@ -1161,7 +1161,7 @@ public static void float3x3_explicit_cast_float4x4()
             TestUtils.AreEqual(expected, (float3x3)f4x4);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_from_float4x4_without_new()
         {
             var f4x4 = new float4x4(new float4(1, 2, 3, 4), new float4(5, 6, 7, 8), new float4(9, 10, 11, 12), new float4(13, 14, 15, 16));
@@ -1170,7 +1170,7 @@ public static void float3x3_from_float4x4_without_new()
             TestUtils.AreEqual(expected, float3x3(f4x4));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_pseudoinverse_non_singular()
         {
             const float kTolerance = 1e-5f;
@@ -1191,7 +1191,7 @@ public static void float3x3_pseudoinverse_non_singular()
             TestUtils.AreEqual(expected, inverse(a), kTolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3x3_pseudoinverse_singular()
         {
             const float kTolerance = 1e-5f;
diff --git a/src/Tests/Tests/Shared/TestMinMaxAABB.cs b/src/Tests/Tests/Shared/TestMinMaxAABB.cs
index a08e52cd..7c5c5e8c 100644
--- a/src/Tests/Tests/Shared/TestMinMaxAABB.cs
+++ b/src/Tests/Tests/Shared/TestMinMaxAABB.cs
@@ -9,7 +9,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestMinMaxAABB
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Encapsulate_float3_trivial()
         {
             var aabb = new MinMaxAABB();
@@ -18,7 +18,7 @@ public static void Encapsulate_float3_trivial()
             TestUtils.AreEqual(float3.zero, aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Encapsulate_float3_new_max()
         {
             var aabb = new MinMaxAABB();
@@ -27,7 +27,7 @@ public static void Encapsulate_float3_new_max()
             TestUtils.AreEqual(new float3(1.0f), aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Encapsulate_float3_new_min()
         {
             var aabb = new MinMaxAABB();
@@ -36,7 +36,7 @@ public static void Encapsulate_float3_new_min()
             TestUtils.AreEqual(new float3(-1.0f), aabb.Min);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Encapsulate_float3_new_minx_maxyz()
         {
             var aabb = new MinMaxAABB();
@@ -45,7 +45,7 @@ public static void Encapsulate_float3_new_minx_maxyz()
             TestUtils.AreEqual(new float3(0.0f, 1.0f, 1.0f), aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Encapsulate_float3_new_minxy_maxz()
         {
             var aabb = new MinMaxAABB();
@@ -54,7 +54,7 @@ public static void Encapsulate_float3_new_minxy_maxz()
             TestUtils.AreEqual(new float3(0.0f, 0.0f, 1.0f), aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Encapsulate_float3_new_minxz_maxy()
         {
             var aabb = new MinMaxAABB();
@@ -63,7 +63,7 @@ public static void Encapsulate_float3_new_minxz_maxy()
             TestUtils.AreEqual(new float3(0.0f, 1.0f, 0.0f), aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Encapsulate_float3_new_minz_maxxy()
         {
             var aabb = new MinMaxAABB();
@@ -72,7 +72,7 @@ public static void Encapsulate_float3_new_minz_maxxy()
             TestUtils.AreEqual(new float3(1.0f, 1.0f, 0.0f), aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Encapsulate_float3_new_miny_maxxz()
         {
             var aabb = new MinMaxAABB();
@@ -81,7 +81,7 @@ public static void Encapsulate_float3_new_miny_maxxz()
             TestUtils.AreEqual(new float3(1.0f, 0.0f, 1.0f), aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Encapsulate_MinMaxAABB_trivial()
         {
             var aabb = new MinMaxAABB();
@@ -90,7 +90,7 @@ public static void Encapsulate_MinMaxAABB_trivial()
             TestUtils.AreEqual(float3.zero, aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Encapsulate_MinMaxAABB_new_max()
         {
             var aabb = new MinMaxAABB();
@@ -100,7 +100,7 @@ public static void Encapsulate_MinMaxAABB_new_max()
             TestUtils.AreEqual(p, aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Encapsulate_MinMaxAABB_new_min()
         {
             var aabb = new MinMaxAABB();
@@ -110,7 +110,7 @@ public static void Encapsulate_MinMaxAABB_new_min()
             TestUtils.AreEqual(p, aabb.Min);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Encapsulate_MinMaxAABB_new_minx_maxyz()
         {
             var aabb = new MinMaxAABB();
@@ -119,7 +119,7 @@ public static void Encapsulate_MinMaxAABB_new_minx_maxyz()
             TestUtils.AreEqual(new float3(0.0f, 1.0f, 1.0f), aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Encapsulate_MinMaxAABB_new_minxy_maxz()
         {
             var aabb = new MinMaxAABB();
@@ -128,7 +128,7 @@ public static void Encapsulate_MinMaxAABB_new_minxy_maxz()
             TestUtils.AreEqual(new float3(0.0f, 0.0f, 1.0f), aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Encapsulate_MinMaxAABB_new_minxz_maxy()
         {
             var aabb = new MinMaxAABB();
@@ -137,7 +137,7 @@ public static void Encapsulate_MinMaxAABB_new_minxz_maxy()
             TestUtils.AreEqual(new float3(0.0f, 1.0f, 0.0f), aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Encapsulate_MinMaxAABB_new_minz_maxxy()
         {
             var aabb = new MinMaxAABB();
@@ -146,7 +146,7 @@ public static void Encapsulate_MinMaxAABB_new_minz_maxxy()
             TestUtils.AreEqual(new float3(1.0f, 1.0f, 0.0f), aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Encapsulate_MinMaxAABB_new_miny_maxxz()
         {
             var aabb = new MinMaxAABB();
@@ -155,14 +155,14 @@ public static void Encapsulate_MinMaxAABB_new_miny_maxxz()
             TestUtils.AreEqual(new float3(1.0f, 0.0f, 1.0f), aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Equals_trivial()
         {
             MinMaxAABB aabb = new MinMaxAABB();
             TestUtils.IsTrue(aabb.Equals(aabb));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Equals()
         {
             MinMaxAABB aabb1 = new MinMaxAABB { Min = new float3(-123.0f, 0.5182f, 20.0f), Max = new float3(1.0f, -1.0f, 0.99191f) };
@@ -171,7 +171,7 @@ public static void Equals()
             TestUtils.IsTrue(aabb2.Equals(aabb1));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Equals_diff_minx()
         {
             MinMaxAABB aabb1 = new MinMaxAABB();
@@ -180,7 +180,7 @@ public static void Equals_diff_minx()
             TestUtils.IsFalse(aabb2.Equals(aabb1));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Equals_diff_miny()
         {
             MinMaxAABB aabb1 = new MinMaxAABB();
@@ -189,7 +189,7 @@ public static void Equals_diff_miny()
             TestUtils.IsFalse(aabb2.Equals(aabb1));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Equals_diff_minz()
         {
             MinMaxAABB aabb1 = new MinMaxAABB();
@@ -198,7 +198,7 @@ public static void Equals_diff_minz()
             TestUtils.IsFalse(aabb2.Equals(aabb1));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Equals_diff_maxx()
         {
             MinMaxAABB aabb1 = new MinMaxAABB();
@@ -207,7 +207,7 @@ public static void Equals_diff_maxx()
             TestUtils.IsFalse(aabb2.Equals(aabb1));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Equals_diff_maxy()
         {
             MinMaxAABB aabb1 = new MinMaxAABB();
@@ -216,7 +216,7 @@ public static void Equals_diff_maxy()
             TestUtils.IsFalse(aabb2.Equals(aabb1));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Equals_diff_maxz()
         {
             MinMaxAABB aabb1 = new MinMaxAABB();
@@ -225,7 +225,7 @@ public static void Equals_diff_maxz()
             TestUtils.IsFalse(aabb2.Equals(aabb1));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void SurfaceArea()
         {
             var min = new float3(-47.989063262939453125f, 28.037994384765625f, -9.756519317626953125f);
@@ -235,7 +235,7 @@ public static void SurfaceArea()
             TestUtils.AreEqual(14400.470703125f, aabb.SurfaceArea, 1, true);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Extents()
         {
             var min = new float3(48.152984619140625f, -33.58978271484375f, -37.498805999755859375f);
@@ -246,7 +246,7 @@ public static void Extents()
             TestUtils.AreEqual(expected, aabb.Extents);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Center()
         {
             var min = new float3(47.902675628662109375f, -34.302494049072265625f, 22.7147884368896484375f);
@@ -257,7 +257,7 @@ public static void Center()
             TestUtils.AreEqual(expected, aabb.Center);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void HalfExtents()
         {
             var min = new float3(-14.3485383987426757813f, 28.68161773681640625f, -40.28060150146484375f);
@@ -268,7 +268,7 @@ public static void HalfExtents()
             TestUtils.AreEqual(expected, aabb.HalfExtents);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Constructor()
         {
             var min = new float3(38.95940399169921875f, -24.644245147705078125f, 27.7903194427490234375f);
@@ -279,7 +279,7 @@ public static void Constructor()
             TestUtils.AreEqual(max, aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ContainsPoint()
         {
             var aabb = new MinMaxAABB(new float3(-1), new float3(1));
@@ -301,7 +301,7 @@ public static void ContainsPoint()
             TestUtils.IsFalse(aabb.Contains(new float3(-1.0f, -1.0f, -1.0f - EPSILON)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ContainsAabb_Trivial()
         {
             var aabb1 = new MinMaxAABB();
@@ -311,7 +311,7 @@ public static void ContainsAabb_Trivial()
             TestUtils.IsTrue(aabb2.Contains(aabb1));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ContainsAabb()
         {
             var aabb1 = new MinMaxAABB(new float3(-1.0f), new float3(1.0f));
@@ -321,7 +321,7 @@ public static void ContainsAabb()
             TestUtils.IsFalse(aabb2.Contains(aabb1));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ContainsAabb_BarelyNotContained()
         {
             var aabb1 = new MinMaxAABB(new float3(-1.0f), new float3(1.0f));
@@ -340,7 +340,7 @@ public static void ContainsAabb_BarelyNotContained()
             TestUtils.IsFalse(aabb1.Contains(aabb7));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Overlap_Trivial()
         {
             var aabb = new MinMaxAABB();
@@ -348,7 +348,7 @@ public static void Overlap_Trivial()
             TestUtils.IsTrue(aabb.Overlaps(aabb));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Overlap_Corner()
         {
             var aabb = new MinMaxAABB(new float3(-1.0f), new float3(1.0f));
@@ -389,7 +389,7 @@ public static void Overlap_Corner()
             TestUtils.IsTrue(cornerAabb8.Overlaps(aabb));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void NoOverlap_Corner()
         {
             var aabb = new MinMaxAABB(new float3(-1.0f), new float3(1.0f));
@@ -430,7 +430,7 @@ public static void NoOverlap_Corner()
             TestUtils.IsFalse(cornerAabb8.Overlaps(aabb));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Expand_PositiveDistance()
         {
             var aabb = new MinMaxAABB(new float3(-0.5f), new float3(0.5f));
@@ -440,7 +440,7 @@ public static void Expand_PositiveDistance()
             TestUtils.AreEqual(new float3(1.5f), aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Expand_NegativeDistance()
         {
             var aabb = new MinMaxAABB(new float3(-0.5f), new float3(0.5f));
@@ -450,7 +450,7 @@ public static void Expand_NegativeDistance()
             TestUtils.AreEqual(new float3(-0.5f), aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void CreateFromCenterAndExtents()
         {
             var center = new float3(-29.2458133697509765625f, 1.21094369888305664063f, 34.281322479248046875f);
@@ -463,7 +463,7 @@ public static void CreateFromCenterAndExtents()
             TestUtils.AreEqual(expectedMax, aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void CreateFromCenterAndHalfExtents()
         {
             var center = new float3(-29.2458133697509765625f, 1.21094369888305664063f, 34.281322479248046875f);
@@ -476,14 +476,14 @@ public static void CreateFromCenterAndHalfExtents()
             TestUtils.AreEqual(expectedMax, aabb.Max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void IsValid_Trivial()
         {
             TestUtils.IsTrue(new MinMaxAABB().IsValid);
             TestUtils.IsFalse(new MinMaxAABB(new float3(1.0f), new float3(-1.0f)).IsValid);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void IsValid_OneComponentInvalid()
         {
             TestUtils.IsFalse(new MinMaxAABB(float3.zero, new float3(-1.0f, 0.0f, 0.0f)).IsValid);
@@ -494,7 +494,7 @@ public static void IsValid_OneComponentInvalid()
             TestUtils.IsFalse(new MinMaxAABB(new float3(0.0f, 0.0f, 1.0f), float3.zero).IsValid);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Transform_RigidTransform()
         {
             var t = new RigidTransform(quaternion.EulerXYZ(PI * 0.25f), new float3(1.0f, 1.0f, 1.0f));
@@ -507,7 +507,7 @@ public static void Transform_RigidTransform()
             TestUtils.AreEqual(expectedMax, aabb.Max, tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Transform_float4x4()
         {
             var t = new float4x4(float3x3.EulerXYZ(PI * 0.25f), new float3(1.0f, 1.0f, 1.0f));
@@ -520,7 +520,7 @@ public static void Transform_float4x4()
             TestUtils.AreEqual(expectedMax, aabb.Max, tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Transform_float3x3()
         {
             var t = float3x3.EulerXYZ(PI * 0.25f);
diff --git a/src/Tests/Tests/Shared/TestPlane.cs b/src/Tests/Tests/Shared/TestPlane.cs
index c79ecb0b..2fbd3251 100644
--- a/src/Tests/Tests/Shared/TestPlane.cs
+++ b/src/Tests/Tests/Shared/TestPlane.cs
@@ -10,7 +10,7 @@ public class TestPlane
         // An arbitrary tolerance.
         const float Tolerance = 0.0000025f;
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Empty()
         {
             var p = new Plane();
@@ -20,7 +20,7 @@ public static void Empty()
             TestUtils.AreEqual(0.0f, p.Distance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void GetNormal()
         {
             var p = new Plane { NormalAndDistance = new float4(1.0f, 2.0f, 3.0f, 4.0f) };
@@ -28,7 +28,7 @@ public static void GetNormal()
             TestUtils.AreEqual(new float3(1.0f, 2.0f, 3.0f), p.Normal);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void GetDistance()
         {
             var p = new Plane { NormalAndDistance = new float4(1.0f, 2.0f, 3.0f, 4.0f) };
@@ -36,7 +36,7 @@ public static void GetDistance()
             TestUtils.AreEqual(4.0f, p.Distance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void SetNormal()
         {
             var p = new Plane { NormalAndDistance = new float4(1.0f, 2.0f, 3.0f, 4.0f) };
@@ -45,7 +45,7 @@ public static void SetNormal()
             TestUtils.AreEqual(new float3(-1.0f, -2.0f, -3.0f), p.Normal);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void SetDistance()
         {
             var p = new Plane { NormalAndDistance = new float4(1.0f, 2.0f, 3.0f, 4.0f) };
@@ -54,7 +54,7 @@ public static void SetDistance()
             TestUtils.AreEqual(-4.0f, p.Distance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ConstructWithNormalAndDistance()
         {
             var n = math.normalize(new float3(4.0f, -5.0f, 6.0f));
@@ -66,7 +66,7 @@ public static void ConstructWithNormalAndDistance()
             TestUtils.AreEqual(d, p.Distance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ConstructWithCoefficients_NonUnitLengthNormal()
         {
             var abcd = new float4(4.0f, -5.0f, 6.0f, 123.0f);
@@ -78,7 +78,7 @@ public static void ConstructWithCoefficients_NonUnitLengthNormal()
             TestUtils.AreEqual(expected.w, p.Distance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ConstructWithNormalAndPointInPlane_NegativeDistance()
         {
             var n = math.up();
@@ -90,7 +90,7 @@ public static void ConstructWithNormalAndPointInPlane_NegativeDistance()
             TestUtils.AreEqual(-1.0f, p.Distance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ConstructWithNormalAndPointInPlane_PositiveDistance()
         {
             var n = math.down();
@@ -102,7 +102,7 @@ public static void ConstructWithNormalAndPointInPlane_PositiveDistance()
             TestUtils.AreEqual(1.0f, p.Distance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ConstructWithNormalAndPointInPlane()
         {
             var normal = new float3(2.0f, 2.0f, 2.0f);
@@ -116,7 +116,7 @@ public static void ConstructWithNormalAndPointInPlane()
             TestUtils.AreEqual(expectedD, p.Distance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ConstructWithTwoVectorsAndOrigin_Trivial()
         {
             var v1 = new float3(1.0f, 0.0f, 0.0f);
@@ -126,7 +126,7 @@ public static void ConstructWithTwoVectorsAndOrigin_Trivial()
             TestUtils.AreEqual(new float4(0.0f, 0.0f, 1.0f, 0.0f), p);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ConstructWithTwoVectorsAndOrigin_NonZeroOrigin()
         {
             var v1 = new float3(5.0f, 0.0f, 0.0f);
@@ -136,7 +136,7 @@ public static void ConstructWithTwoVectorsAndOrigin_NonZeroOrigin()
             TestUtils.AreEqual(new float4(0.0f, 0.0f, -1.0f, 1.0f), p);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void SignedDistanceToPoint()
         {
             var vInPlane1 = new float3(2.0f, 1.0f, -0.18f);
@@ -152,7 +152,7 @@ public static void SignedDistanceToPoint()
             TestUtils.AreEqual(-1.0f, p.SignedDistanceToPoint(pointInPlane - n), Tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void SignedDistanceToPointTrivial()
         {
             var p = new Plane(math.up(), 0.0f);
@@ -174,7 +174,7 @@ public static void SignedDistanceToPointTrivial()
             TestUtils.AreEqual(-1.0f, p.SignedDistanceToPoint(math.down() + math.forward()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ProjectionTrivial()
         {
             var p = new Plane(math.up(), 0.0f);
@@ -183,7 +183,7 @@ public static void ProjectionTrivial()
             TestUtils.AreEqual(expected, p.Projection(math.up() + expected));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Projection()
         {
             var normal = new float3(1.0f);
@@ -195,7 +195,7 @@ public static void Projection()
             TestUtils.AreEqual(expected, p.Projection(expected), math.EPSILON);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void Flipped()
         {
             var normal = new float3(1.0f);
@@ -207,7 +207,7 @@ public static void Flipped()
             TestUtils.AreEqual(new float4(expectedN, expectedD), p.Flipped, Tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void ImplicitToFloat4()
         {
             var normal = new float3(1.1f, -20.0f, 15.182f);
@@ -220,7 +220,7 @@ public static void ImplicitToFloat4()
             TestUtils.AreEqual(new float4(expectedN, expectedD), p_as_float4, Tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void NormalizeFloat4()
         {
             var p = new float4(8.215876543024162e-01f, 2.786574280629829e-01f, 8.121669997361285e-01f, 9.352839276497152e-01f);
@@ -229,7 +229,7 @@ public static void NormalizeFloat4()
             TestUtils.AreEqual(expected, Plane.Normalize(p), Tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void NormalizePlane()
         {
             var p = new Plane { NormalAndDistance = new float4(8.215876543024162e-01f, 2.786574280629829e-01f, 8.121669997361285e-01f, 9.352839276497152e-01f) };
@@ -241,7 +241,7 @@ public static void NormalizePlane()
             TestUtils.AreEqual(expected.w, normalized.Distance, Tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void CreateFromUnitNormalAndDistance()
         {
             var n = new float3(9.108767140247756e-02f, 3.966831912609620e-01f, 9.134251375397404e-01f);
@@ -252,7 +252,7 @@ public static void CreateFromUnitNormalAndDistance()
             TestUtils.AreEqual(expected, p.NormalAndDistance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void CreateFromUnitNormalAndPointInPlane()
         {
             var n = new float3(4.724920516359185e-01f, 1.444614284194820e-01f, 8.694148358751899e-01f);
@@ -263,4 +263,4 @@ public static void CreateFromUnitNormalAndPointInPlane()
             TestUtils.AreEqual(expected, p.NormalAndDistance, Tolerance);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Tests/Tests/Shared/TestQuaternion.cs b/src/Tests/Tests/Shared/TestQuaternion.cs
index 0279de90..301725ee 100644
--- a/src/Tests/Tests/Shared/TestQuaternion.cs
+++ b/src/Tests/Tests/Shared/TestQuaternion.cs
@@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     class TestQuaternion
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_basic_constructors()
         {
             quaternion q = quaternion(1.0f, 2.0f, 3.0f, 4.0f);
@@ -23,7 +23,7 @@ public static void quaternion_basic_constructors()
             TestUtils.AreEqual(4.0f, q2.value.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_construct_from_matrix()
         {
             TestUtils.AreEqual(float3x3(quaternion(TestMatrix.test3x3_xyz)), TestMatrix.test3x3_xyz, 0.0001f);
@@ -45,7 +45,7 @@ public static void quaternion_construct_from_matrix()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_construct_from_matrix3x3_torture()
         {
             Random rnd = new Random(0x12345678);
@@ -58,7 +58,7 @@ public static void quaternion_construct_from_matrix3x3_torture()
             }
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_construct_from_matrix4x4_torture()
         {
             Random rnd = new Random(0x12345678);
@@ -71,7 +71,7 @@ public static void quaternion_construct_from_matrix4x4_torture()
             }
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_axis_angle()
         {
             quaternion q = quaternion.AxisAngle(normalize(float3(1.0f, 2.0f, 3.0f)), 10.0f);
@@ -80,7 +80,7 @@ public static void quaternion_axis_angle()
             TestUtils.AreEqual(r, q, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_axis_angle_consistency()
         {
             TestUtils.AreEqual(quaternion.RotateX(1.0f), quaternion.AxisAngle(float3(1, 0, 0), 1.0f), 0.001f);
@@ -88,7 +88,7 @@ public static void quaternion_axis_angle_consistency()
             TestUtils.AreEqual(quaternion.RotateZ(1.0f), quaternion.AxisAngle(float3(0, 0, 1), 1.0f), 0.001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void euler_to_quaternion()
         {
             float3 test_angles = TestMatrix.test_angles;
@@ -158,7 +158,7 @@ public static void euler_to_quaternion()
             TestUtils.AreEqual(TestMatrix.test3x3_zyx, m1_zyx, epsilon);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_rotateX()
         {
             float angle = 2.3f;
@@ -168,7 +168,7 @@ public static void quaternion_rotateX()
             TestUtils.AreEqual(r, q, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_rotateY()
         {
             float angle = 2.3f;
@@ -178,7 +178,7 @@ public static void quaternion_rotateY()
             TestUtils.AreEqual(r, q, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_rotateZ()
         {
             float angle = 2.3f;
@@ -193,7 +193,7 @@ public static void quaternion_rotateZ()
         static internal readonly quaternion test_q2 = new quaternion(-0.2316205f, -0.6022133f, -0.7411857f, -0.1852964f);
         static internal readonly quaternion test_q3 = new quaternion(0.3619499f, 0.8352691f, -0.1392115f, 0.3897922f);
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_conjugate()
         {
             quaternion q = quaternion(1.0f, -2.0f, 3.0f, -4.0f);
@@ -203,7 +203,7 @@ public static void quaternion_conjugate()
             TestUtils.AreEqual(r, cq);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_inverse()
         {
             quaternion q = quaternion(1.0f, -2.0f, 3.0f, -4.0f);
@@ -213,7 +213,7 @@ public static void quaternion_inverse()
             TestUtils.AreEqual(quaternion.identity, qiq, 0.00001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_dot()
         {
             float dot01 = dot(test_q0, test_q1);
@@ -223,7 +223,7 @@ public static void quaternion_dot()
             TestUtils.AreEqual(-0.5795583f, dot02, 0.00001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_nlerp()
         {
             quaternion r0 = nlerp(test_q0, test_q1, 0.3f);
@@ -235,7 +235,7 @@ public static void quaternion_nlerp()
             TestUtils.AreEqual(quaternion(-0.4054004f, 0.06570576f, -0.7457358f, -0.5246059f), r2, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_slerp()
         {
             quaternion r0 = slerp(test_q0, test_q1, 0.3f);
@@ -247,7 +247,7 @@ public static void quaternion_slerp()
             TestUtils.AreEqual(quaternion(0.2596942f, -0.4369303f, 0.7902023f, 0.34239f), r2, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_mul_vector()
         {
             float3x3 m = TestMatrix.test3x3_xyz;
@@ -261,7 +261,7 @@ public static void quaternion_mul_vector()
             TestUtils.AreEqual(mvector, qvector, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_log_exp_identity()
         {
             quaternion q = quaternion(1.2f, -2.6f, 3.1f, 6.0f);
@@ -270,7 +270,7 @@ public static void quaternion_log_exp_identity()
             TestUtils.AreEqual(q, exp_log_q, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_log_exp_rotation()
         {
             quaternion q = quaternion(TestMatrix.test3x3_xyz);
@@ -280,7 +280,7 @@ public static void quaternion_log_exp_rotation()
             TestUtils.AreEqual(q3, t, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_unitlog_unitexp_rotation()
         {
             quaternion q = quaternion(TestMatrix.test3x3_xyz);
@@ -290,7 +290,7 @@ public static void quaternion_unitlog_unitexp_rotation()
             TestUtils.AreEqual(q3, t, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_look_rotation()
         {
             // Exercise the 4 cases
@@ -319,7 +319,7 @@ public static void quaternion_look_rotation()
             TestUtils.AreEqual(float3x3.LookRotation(forward3, up3), float3x3(q3), 0.001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_look_rotation_safe()
         {
             float3 forward0 = float3(-3.2f, 2.3f, -1.3f) * 1e-10f;
@@ -381,7 +381,7 @@ public static void quaternion_angle()
             TestUtils.AreEqual(0f, angle);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_rotation_from_3x3_identity()
         {
             const float tolerance = 1e-5f;
@@ -389,7 +389,7 @@ public static void quaternion_rotation_from_3x3_identity()
             TestUtils.AreEqual(quaternion.identity, q, tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_rotation_from_3x3_with_uniform_scale()
         {
             const float tolerance = 1e-5f;
@@ -401,7 +401,7 @@ public static void quaternion_rotation_from_3x3_with_uniform_scale()
             TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_rotation_from_3x3_with_nonuniform_scale()
         {
             const float tolerance = 1e-5f;
@@ -413,7 +413,7 @@ public static void quaternion_rotation_from_3x3_with_nonuniform_scale()
             TestUtils.AreEqual(quaternion.identity, q, tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_rotation_from_3x3_with_negative_scale_x()
         {
             const float tolerance = 1e-5f;
@@ -425,7 +425,7 @@ public static void quaternion_rotation_from_3x3_with_negative_scale_x()
             TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_rotation_from_3x3_with_negative_scale_y()
         {
             const float tolerance = 1e-5f;
@@ -437,7 +437,7 @@ public static void quaternion_rotation_from_3x3_with_negative_scale_y()
             TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_rotation_from_3x3_with_negative_scale_z()
         {
             const float tolerance = 1e-5f;
@@ -449,7 +449,7 @@ public static void quaternion_rotation_from_3x3_with_negative_scale_z()
             TestUtils.AreEqual(0.0f, angle(actualQuaternion, expectedQuaternion) % PI * 2.0f, tolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_rotation_from_3x3_with_negative_nonuniform_scale()
         {
             const float tolerance = 1e-5f;
diff --git a/src/Tests/Tests/Shared/TestRigidTransform.cs b/src/Tests/Tests/Shared/TestRigidTransform.cs
index eacec9ed..ac0d8060 100644
--- a/src/Tests/Tests/Shared/TestRigidTransform.cs
+++ b/src/Tests/Tests/Shared/TestRigidTransform.cs
@@ -7,7 +7,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     class TestRigidTransform
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rigid_transform_construct_from_matrix()
         {
             float4x4 m4x4 = TestMatrix.test4x4_zyx;
@@ -19,7 +19,7 @@ public static void rigid_transform_construct_from_matrix()
             TestUtils.AreEqual(m4x4, mq4x4, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rigid_transform_axisAngle()
         {
             RigidTransform q = RigidTransform.AxisAngle(normalize(float3(1.0f, 2.0f, 3.0f)), 10.0f);
@@ -28,7 +28,7 @@ public static void rigid_transform_axisAngle()
             TestUtils.AreEqual(r, q, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rigid_transform_euler()
         {
             float3 test_angles = TestMatrix.test_angles;
@@ -98,7 +98,7 @@ public static void rigid_transform_euler()
             TestUtils.AreEqual(TestMatrix.test3x3_zyx, m1_zyx, epsilon);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rigid_transform_rotateX()
         {
             float angle = 2.3f;
@@ -108,7 +108,7 @@ public static void rigid_transform_rotateX()
             TestUtils.AreEqual(r, q, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rigid_transform_rotateY()
         {
             float angle = 2.3f;
@@ -118,7 +118,7 @@ public static void rigid_transform_rotateY()
             TestUtils.AreEqual(r, q, 0.0001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rigid_transform_rotateZ()
         {
             float angle = 2.3f;
@@ -133,7 +133,7 @@ public static void rigid_transform_rotateZ()
         static internal readonly quaternion test_q2 = new quaternion(-0.2316205f, -0.6022133f, -0.7411857f, -0.1852964f);
         static internal readonly quaternion test_q3 = new quaternion(0.3619499f, 0.8352691f, -0.1392115f, 0.3897922f);
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rigid_transform_inverse()
         {
             RigidTransform q = RigidTransform(quaternion(1.0f, -2.0f, 3.0f, -4.0f), float3(1,2,3));
@@ -143,7 +143,7 @@ public static void rigid_transform_inverse()
             TestUtils.AreEqual(RigidTransform.identity, qiq, 0.00001f);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void rigid_transform_mul_vector()
         {
             float4x4 m = TestMatrix.test4x4_xyz;
diff --git a/src/Tests/Tests/Shared/TestSvd.cs b/src/Tests/Tests/Shared/TestSvd.cs
index db889bd9..e75cf04f 100644
--- a/src/Tests/Tests/Shared/TestSvd.cs
+++ b/src/Tests/Tests/Shared/TestSvd.cs
@@ -48,7 +48,7 @@ static void ValidatePenrose2(in float3x3 a, in float3x3 b)
         static void ValidateSingular(in float3x3 a) =>
             TestUtils.AreEqual(0.0f, math.determinant(a), k_SVDTolerance);
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void CanSVDInverseNonSingularFloat3x3()
         {
             var mat = math.float3x3(
@@ -71,7 +71,7 @@ public static void CanSVDInverseNonSingularFloat3x3()
             TestUtils.AreEqual(1f, testIdentity.c2.z, k_SVDTolerance);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void CanSVDInverseFloat3x3With_NullColumn()
         {
             var mat = math.float3x3(
@@ -89,7 +89,7 @@ public static void CanSVDInverseFloat3x3With_NullColumn()
             ValidatePenrose2(inv, mat);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void CanSVDInverseFloat3x3With_NullRow()
         {
             var mat = math.float3x3(
@@ -107,7 +107,7 @@ public static void CanSVDInverseFloat3x3With_NullRow()
             ValidatePenrose2(inv, mat);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void CanSVDInverseFloat3x3With_LinearDependentColumn()
         {
             var mat = math.float3x3(
@@ -125,7 +125,7 @@ public static void CanSVDInverseFloat3x3With_LinearDependentColumn()
             ValidatePenrose2(inv, mat);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void CanSVDInverseFloat3x3With_LinearDependentRow()
         {
             var mat = math.float3x3(
@@ -143,7 +143,7 @@ public static void CanSVDInverseFloat3x3With_LinearDependentRow()
             ValidatePenrose2(inv, mat);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void CanSVDInverseFloat3x3With_RotatedZeroScale()
         {
             var m102030 = math.float3x3(quaternion.Euler(math.radians(10f), math.radians(20f), math.radians(30f)));
@@ -160,7 +160,7 @@ public static void CanSVDInverseFloat3x3With_RotatedZeroScale()
         }
 
         // Case 928598: The errors appear, when GameObject has a child with ParticleSystem which is rotated along the y-axis to -180 and is moved
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void CanExtractSVDRotationFromFloat3x3With_X180_Y0_Z181()
         {
             var q = quaternion.Euler(math.radians(180f), math.radians(0f), math.radians(181f));
@@ -170,7 +170,7 @@ public static void CanExtractSVDRotationFromFloat3x3With_X180_Y0_Z181()
         }
 
         // Case 938548: Assertion failed on expression: 'CompareApproximately(det, 1.0F, .005f)' when scaling system to 0 on at least 2 axes
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void CanExtractSVDRotationFromFloat3x3With_ZeroScaleXY()
         {
             var q0 = quaternion.Euler(math.radians(10f), math.radians(20f), math.radians(30f));
@@ -182,4 +182,4 @@ public static void CanExtractSVDRotationFromFloat3x3With_ZeroScaleXY()
             TestUtils.AreEqual(0.0f, math.length(m0.c0 - m1.c0), k_SVDTolerance);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Tests/Tests/Shared/TestUint2.gen.cs b/src/Tests/Tests/Shared/TestUint2.gen.cs
index 04620a33..d853e034 100644
--- a/src/Tests/Tests/Shared/TestUint2.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint2.gen.cs
@@ -15,14 +15,14 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_zero()
         {
             TestUtils.AreEqual(0u, uint2.zero.x);
             TestUtils.AreEqual(0u, uint2.zero.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_constructor()
         {
             uint2 a = new uint2(1, 2);
@@ -30,7 +30,7 @@ public static void uint2_constructor()
             TestUtils.AreEqual(2, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_scalar_constructor()
         {
             uint2 a = new uint2(17u);
@@ -38,7 +38,7 @@ public static void uint2_scalar_constructor()
             TestUtils.AreEqual(17u, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_static_constructor()
         {
             uint2 a = uint2(1, 2);
@@ -46,7 +46,7 @@ public static void uint2_static_constructor()
             TestUtils.AreEqual(2, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_static_scalar_constructor()
         {
             uint2 a = uint2(17u);
@@ -54,7 +54,7 @@ public static void uint2_static_scalar_constructor()
             TestUtils.AreEqual(17u, a.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_equal_wide_wide()
         {
             uint2 a0 = uint2(2105871082, 35218899);
@@ -78,7 +78,7 @@ public static void uint2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_equal_wide_scalar()
         {
             uint2 a0 = uint2(437822262, 2020661134);
@@ -102,7 +102,7 @@ public static void uint2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -126,7 +126,7 @@ public static void uint2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_not_equal_wide_wide()
         {
             uint2 a0 = uint2(1977284100, 1293292704);
@@ -150,7 +150,7 @@ public static void uint2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_not_equal_wide_scalar()
         {
             uint2 a0 = uint2(1038269360, 1427812625);
@@ -174,7 +174,7 @@ public static void uint2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -198,7 +198,7 @@ public static void uint2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_less_wide_wide()
         {
             uint2 a0 = uint2(1486550609, 1779244308);
@@ -222,7 +222,7 @@ public static void uint2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_less_wide_scalar()
         {
             uint2 a0 = uint2(796797557, 670113454);
@@ -246,7 +246,7 @@ public static void uint2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -270,7 +270,7 @@ public static void uint2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_greater_wide_wide()
         {
             uint2 a0 = uint2(2087717754, 1725569452);
@@ -294,7 +294,7 @@ public static void uint2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_greater_wide_scalar()
         {
             uint2 a0 = uint2(1208626274, 239697208);
@@ -318,7 +318,7 @@ public static void uint2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -342,7 +342,7 @@ public static void uint2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_less_equal_wide_wide()
         {
             uint2 a0 = uint2(154092149, 1515170149);
@@ -366,7 +366,7 @@ public static void uint2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_less_equal_wide_scalar()
         {
             uint2 a0 = uint2(1479531977, 1427983411);
@@ -390,7 +390,7 @@ public static void uint2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -414,7 +414,7 @@ public static void uint2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_greater_equal_wide_wide()
         {
             uint2 a0 = uint2(8538378, 2131749726);
@@ -438,7 +438,7 @@ public static void uint2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_greater_equal_wide_scalar()
         {
             uint2 a0 = uint2(2049236663, 182691143);
@@ -462,7 +462,7 @@ public static void uint2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -486,7 +486,7 @@ public static void uint2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_add_wide_wide()
         {
             uint2 a0 = uint2(2135171378, 21433296);
@@ -510,7 +510,7 @@ public static void uint2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_add_wide_scalar()
         {
             uint2 a0 = uint2(665815972, 1783729250);
@@ -534,7 +534,7 @@ public static void uint2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -558,7 +558,7 @@ public static void uint2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_sub_wide_wide()
         {
             uint2 a0 = uint2(1410318491, 1097280168);
@@ -582,7 +582,7 @@ public static void uint2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_sub_wide_scalar()
         {
             uint2 a0 = uint2(1508669340, 1594795463);
@@ -606,7 +606,7 @@ public static void uint2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -630,7 +630,7 @@ public static void uint2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_mul_wide_wide()
         {
             uint2 a0 = uint2(61417577, 219585476);
@@ -654,7 +654,7 @@ public static void uint2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_mul_wide_scalar()
         {
             uint2 a0 = uint2(871746615, 492532311);
@@ -678,7 +678,7 @@ public static void uint2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -702,7 +702,7 @@ public static void uint2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_div_wide_wide()
         {
             uint2 a0 = uint2(333171510, 858154903);
@@ -726,7 +726,7 @@ public static void uint2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_div_wide_scalar()
         {
             uint2 a0 = uint2(1433072926, 1073958635);
@@ -750,7 +750,7 @@ public static void uint2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -774,7 +774,7 @@ public static void uint2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_mod_wide_wide()
         {
             uint2 a0 = uint2(258342924, 1454754891);
@@ -798,7 +798,7 @@ public static void uint2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_mod_wide_scalar()
         {
             uint2 a0 = uint2(560988938, 629524514);
@@ -822,7 +822,7 @@ public static void uint2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -846,7 +846,7 @@ public static void uint2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_plus()
         {
             uint2 a0 = uint2(195392567, 222719748);
@@ -866,7 +866,7 @@ public static void uint2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_neg()
         {
             uint2 a0 = uint2(1385088677, 94114564);
@@ -886,7 +886,7 @@ public static void uint2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_prefix_inc()
         {
             uint2 a0 = uint2(780471723, 954741756);
@@ -906,7 +906,7 @@ public static void uint2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_postfix_inc()
         {
             uint2 a0 = uint2(241865086, 2145821641);
@@ -926,7 +926,7 @@ public static void uint2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_prefix_dec()
         {
             uint2 a0 = uint2(1331961415, 1612382200);
@@ -946,7 +946,7 @@ public static void uint2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_postfix_dec()
         {
             uint2 a0 = uint2(1870005937, 1708534798);
@@ -966,7 +966,7 @@ public static void uint2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_bitwise_and_wide_wide()
         {
             uint2 a0 = uint2(1055241304, 859321394);
@@ -990,7 +990,7 @@ public static void uint2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_bitwise_and_wide_scalar()
         {
             uint2 a0 = uint2(1513158868, 284695609);
@@ -1014,7 +1014,7 @@ public static void uint2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1038,7 +1038,7 @@ public static void uint2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_bitwise_or_wide_wide()
         {
             uint2 a0 = uint2(1920951869, 1750772852);
@@ -1062,7 +1062,7 @@ public static void uint2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_bitwise_or_wide_scalar()
         {
             uint2 a0 = uint2(1295304853, 1307252624);
@@ -1086,7 +1086,7 @@ public static void uint2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1110,7 +1110,7 @@ public static void uint2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_bitwise_xor_wide_wide()
         {
             uint2 a0 = uint2(1843655608, 362425681);
@@ -1134,7 +1134,7 @@ public static void uint2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_bitwise_xor_wide_scalar()
         {
             uint2 a0 = uint2(169345668, 176087064);
@@ -1158,7 +1158,7 @@ public static void uint2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1182,7 +1182,7 @@ public static void uint2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_left_shift()
         {
             uint2 a0 = uint2(1129100049, 829482269);
@@ -1206,7 +1206,7 @@ public static void uint2_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_right_shift()
         {
             uint2 a0 = uint2(809126085, 908563670);
@@ -1230,7 +1230,7 @@ public static void uint2_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_operator_bitwise_not()
         {
             uint2 a0 = uint2(111796841, 603562399);
@@ -1250,7 +1250,7 @@ public static void uint2_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_shuffle_result_1()
         {
             uint2 a = uint2(0, 1);
@@ -1262,7 +1262,7 @@ public static void uint2_shuffle_result_1()
             TestUtils.AreEqual((3), shuffle(a, b, ShuffleComponent.RightY));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_shuffle_result_2()
         {
             uint2 a = uint2(0, 1);
@@ -1286,7 +1286,7 @@ public static void uint2_shuffle_result_2()
             TestUtils.AreEqual(uint2(3, 3), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_shuffle_result_3()
         {
             uint2 a = uint2(0, 1);
@@ -1310,7 +1310,7 @@ public static void uint2_shuffle_result_3()
             TestUtils.AreEqual(uint3(3, 1, 1), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_shuffle_result_4()
         {
             uint2 a = uint2(0, 1);
diff --git a/src/Tests/Tests/Shared/TestUint2x2.gen.cs b/src/Tests/Tests/Shared/TestUint2x2.gen.cs
index dd8ed7a4..012db8aa 100644
--- a/src/Tests/Tests/Shared/TestUint2x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint2x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint2x2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_zero()
         {
             TestUtils.AreEqual(0u, uint2x2.zero.c0.x);
@@ -24,7 +24,7 @@ public static void uint2x2_zero()
             TestUtils.AreEqual(0u, uint2x2.zero.c1.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_identity()
         {
             TestUtils.AreEqual(1u, uint2x2.identity.c0.x);
@@ -33,7 +33,7 @@ public static void uint2x2_identity()
             TestUtils.AreEqual(1u, uint2x2.identity.c1.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_equal_wide_wide()
         {
             uint2x2 a0 = uint2x2(2105871082, 35218899, 1550755093, 764676020);
@@ -57,7 +57,7 @@ public static void uint2x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_equal_wide_scalar()
         {
             uint2x2 a0 = uint2x2(437822262, 2020661134, 541786900, 853113810);
@@ -81,7 +81,7 @@ public static void uint2x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -105,7 +105,7 @@ public static void uint2x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_not_equal_wide_wide()
         {
             uint2x2 a0 = uint2x2(1977284100, 1293292704, 1547283851, 422428953);
@@ -129,7 +129,7 @@ public static void uint2x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_not_equal_wide_scalar()
         {
             uint2x2 a0 = uint2x2(1038269360, 1427812625, 103361237, 1347017023);
@@ -153,7 +153,7 @@ public static void uint2x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -177,7 +177,7 @@ public static void uint2x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_less_wide_wide()
         {
             uint2x2 a0 = uint2x2(1486550609, 1779244308, 1602148045, 1614085440);
@@ -201,7 +201,7 @@ public static void uint2x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_less_wide_scalar()
         {
             uint2x2 a0 = uint2x2(796797557, 670113454, 933579492, 278884514);
@@ -225,7 +225,7 @@ public static void uint2x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -249,7 +249,7 @@ public static void uint2x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_greater_wide_wide()
         {
             uint2x2 a0 = uint2x2(2087717754, 1725569452, 1298066182, 1693943616);
@@ -273,7 +273,7 @@ public static void uint2x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_greater_wide_scalar()
         {
             uint2x2 a0 = uint2x2(1208626274, 239697208, 1979453345, 1253474001);
@@ -297,7 +297,7 @@ public static void uint2x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -321,7 +321,7 @@ public static void uint2x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_less_equal_wide_wide()
         {
             uint2x2 a0 = uint2x2(154092149, 1515170149, 1083970332, 785807178);
@@ -345,7 +345,7 @@ public static void uint2x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_less_equal_wide_scalar()
         {
             uint2x2 a0 = uint2x2(1479531977, 1427983411, 415250630, 1245345407);
@@ -369,7 +369,7 @@ public static void uint2x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -393,7 +393,7 @@ public static void uint2x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_greater_equal_wide_wide()
         {
             uint2x2 a0 = uint2x2(8538378, 2131749726, 265427108, 523609761);
@@ -417,7 +417,7 @@ public static void uint2x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_greater_equal_wide_scalar()
         {
             uint2x2 a0 = uint2x2(2049236663, 182691143, 634973382, 1197012109);
@@ -441,7 +441,7 @@ public static void uint2x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -465,7 +465,7 @@ public static void uint2x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_add_wide_wide()
         {
             uint2x2 a0 = uint2x2(2135171378, 21433296, 1954723494, 683604307);
@@ -489,7 +489,7 @@ public static void uint2x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_add_wide_scalar()
         {
             uint2x2 a0 = uint2x2(665815972, 1783729250, 1591678394, 1284528538);
@@ -513,7 +513,7 @@ public static void uint2x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -537,7 +537,7 @@ public static void uint2x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_sub_wide_wide()
         {
             uint2x2 a0 = uint2x2(1410318491, 1097280168, 1827039044, 28881338);
@@ -561,7 +561,7 @@ public static void uint2x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_sub_wide_scalar()
         {
             uint2x2 a0 = uint2x2(1508669340, 1594795463, 266707545, 643102647);
@@ -585,7 +585,7 @@ public static void uint2x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -609,7 +609,7 @@ public static void uint2x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_mul_wide_wide()
         {
             uint2x2 a0 = uint2x2(61417577, 219585476, 1362520891, 1511084277);
@@ -633,7 +633,7 @@ public static void uint2x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_mul_wide_scalar()
         {
             uint2x2 a0 = uint2x2(871746615, 492532311, 570557670, 2142306629);
@@ -657,7 +657,7 @@ public static void uint2x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -681,7 +681,7 @@ public static void uint2x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_div_wide_wide()
         {
             uint2x2 a0 = uint2x2(333171510, 858154903, 1181365836, 671357749);
@@ -705,7 +705,7 @@ public static void uint2x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_div_wide_scalar()
         {
             uint2x2 a0 = uint2x2(1433072926, 1073958635, 1195142312, 536596719);
@@ -729,7 +729,7 @@ public static void uint2x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -753,7 +753,7 @@ public static void uint2x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_mod_wide_wide()
         {
             uint2x2 a0 = uint2x2(258342924, 1454754891, 723352342, 1981431473);
@@ -777,7 +777,7 @@ public static void uint2x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_mod_wide_scalar()
         {
             uint2x2 a0 = uint2x2(560988938, 629524514, 767711194, 434281967);
@@ -801,7 +801,7 @@ public static void uint2x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -825,7 +825,7 @@ public static void uint2x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_plus()
         {
             uint2x2 a0 = uint2x2(195392567, 222719748, 1002351013, 1570765263);
@@ -845,7 +845,7 @@ public static void uint2x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_neg()
         {
             uint2x2 a0 = uint2x2(1385088677, 94114564, 1350664872, 1458616659);
@@ -865,7 +865,7 @@ public static void uint2x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_prefix_inc()
         {
             uint2x2 a0 = uint2x2(780471723, 954741756, 272723451, 2142862245);
@@ -885,7 +885,7 @@ public static void uint2x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_postfix_inc()
         {
             uint2x2 a0 = uint2x2(241865086, 2145821641, 1596166022, 803592338);
@@ -905,7 +905,7 @@ public static void uint2x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_prefix_dec()
         {
             uint2x2 a0 = uint2x2(1331961415, 1612382200, 1401591249, 2042075388);
@@ -925,7 +925,7 @@ public static void uint2x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_postfix_dec()
         {
             uint2x2 a0 = uint2x2(1870005937, 1708534798, 704493460, 462940703);
@@ -945,7 +945,7 @@ public static void uint2x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_bitwise_and_wide_wide()
         {
             uint2x2 a0 = uint2x2(1055241304, 859321394, 1088358961, 2090949513);
@@ -969,7 +969,7 @@ public static void uint2x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_bitwise_and_wide_scalar()
         {
             uint2x2 a0 = uint2x2(1513158868, 284695609, 734595037, 1566510707);
@@ -993,7 +993,7 @@ public static void uint2x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1017,7 +1017,7 @@ public static void uint2x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_bitwise_or_wide_wide()
         {
             uint2x2 a0 = uint2x2(1920951869, 1750772852, 1420019191, 732977093);
@@ -1041,7 +1041,7 @@ public static void uint2x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_bitwise_or_wide_scalar()
         {
             uint2x2 a0 = uint2x2(1295304853, 1307252624, 350194630, 1128063578);
@@ -1065,7 +1065,7 @@ public static void uint2x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1089,7 +1089,7 @@ public static void uint2x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_bitwise_xor_wide_wide()
         {
             uint2x2 a0 = uint2x2(1843655608, 362425681, 640805534, 1342040268);
@@ -1113,7 +1113,7 @@ public static void uint2x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_bitwise_xor_wide_scalar()
         {
             uint2x2 a0 = uint2x2(169345668, 176087064, 2084362901, 1663924004);
@@ -1137,7 +1137,7 @@ public static void uint2x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1161,7 +1161,7 @@ public static void uint2x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_left_shift()
         {
             uint2x2 a0 = uint2x2(1129100049, 829482269, 1571297368, 443753193);
@@ -1185,7 +1185,7 @@ public static void uint2x2_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_right_shift()
         {
             uint2x2 a0 = uint2x2(809126085, 908563670, 763568837, 1986717290);
@@ -1209,7 +1209,7 @@ public static void uint2x2_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x2_operator_bitwise_not()
         {
             uint2x2 a0 = uint2x2(111796841, 603562399, 745091931, 853183268);
diff --git a/src/Tests/Tests/Shared/TestUint2x3.gen.cs b/src/Tests/Tests/Shared/TestUint2x3.gen.cs
index 0dcca69a..ac053495 100644
--- a/src/Tests/Tests/Shared/TestUint2x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint2x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint2x3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_zero()
         {
             TestUtils.AreEqual(0u, uint2x3.zero.c0.x);
@@ -26,7 +26,7 @@ public static void uint2x3_zero()
             TestUtils.AreEqual(0u, uint2x3.zero.c2.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_equal_wide_wide()
         {
             uint2x3 a0 = uint2x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098);
@@ -50,7 +50,7 @@ public static void uint2x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_equal_wide_scalar()
         {
             uint2x3 a0 = uint2x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405);
@@ -74,7 +74,7 @@ public static void uint2x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -98,7 +98,7 @@ public static void uint2x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_not_equal_wide_wide()
         {
             uint2x3 a0 = uint2x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892);
@@ -122,7 +122,7 @@ public static void uint2x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_not_equal_wide_scalar()
         {
             uint2x3 a0 = uint2x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802);
@@ -146,7 +146,7 @@ public static void uint2x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -170,7 +170,7 @@ public static void uint2x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_less_wide_wide()
         {
             uint2x3 a0 = uint2x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342);
@@ -194,7 +194,7 @@ public static void uint2x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_less_wide_scalar()
         {
             uint2x3 a0 = uint2x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673);
@@ -218,7 +218,7 @@ public static void uint2x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -242,7 +242,7 @@ public static void uint2x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_greater_wide_wide()
         {
             uint2x3 a0 = uint2x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491);
@@ -266,7 +266,7 @@ public static void uint2x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_greater_wide_scalar()
         {
             uint2x3 a0 = uint2x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635);
@@ -290,7 +290,7 @@ public static void uint2x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -314,7 +314,7 @@ public static void uint2x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_less_equal_wide_wide()
         {
             uint2x3 a0 = uint2x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627);
@@ -338,7 +338,7 @@ public static void uint2x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_less_equal_wide_scalar()
         {
             uint2x3 a0 = uint2x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632);
@@ -362,7 +362,7 @@ public static void uint2x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -386,7 +386,7 @@ public static void uint2x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_greater_equal_wide_wide()
         {
             uint2x3 a0 = uint2x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564);
@@ -410,7 +410,7 @@ public static void uint2x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_greater_equal_wide_scalar()
         {
             uint2x3 a0 = uint2x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469);
@@ -434,7 +434,7 @@ public static void uint2x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -458,7 +458,7 @@ public static void uint2x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_add_wide_wide()
         {
             uint2x3 a0 = uint2x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995);
@@ -482,7 +482,7 @@ public static void uint2x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_add_wide_scalar()
         {
             uint2x3 a0 = uint2x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732);
@@ -506,7 +506,7 @@ public static void uint2x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -530,7 +530,7 @@ public static void uint2x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_sub_wide_wide()
         {
             uint2x3 a0 = uint2x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868);
@@ -554,7 +554,7 @@ public static void uint2x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_sub_wide_scalar()
         {
             uint2x3 a0 = uint2x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328);
@@ -578,7 +578,7 @@ public static void uint2x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -602,7 +602,7 @@ public static void uint2x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_mul_wide_wide()
         {
             uint2x3 a0 = uint2x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871);
@@ -626,7 +626,7 @@ public static void uint2x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_mul_wide_scalar()
         {
             uint2x3 a0 = uint2x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563);
@@ -650,7 +650,7 @@ public static void uint2x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -674,7 +674,7 @@ public static void uint2x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_div_wide_wide()
         {
             uint2x3 a0 = uint2x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420);
@@ -698,7 +698,7 @@ public static void uint2x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_div_wide_scalar()
         {
             uint2x3 a0 = uint2x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346);
@@ -722,7 +722,7 @@ public static void uint2x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -746,7 +746,7 @@ public static void uint2x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_mod_wide_wide()
         {
             uint2x3 a0 = uint2x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627);
@@ -770,7 +770,7 @@ public static void uint2x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_mod_wide_scalar()
         {
             uint2x3 a0 = uint2x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846);
@@ -794,7 +794,7 @@ public static void uint2x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -818,7 +818,7 @@ public static void uint2x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_plus()
         {
             uint2x3 a0 = uint2x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277);
@@ -838,7 +838,7 @@ public static void uint2x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_neg()
         {
             uint2x3 a0 = uint2x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493);
@@ -858,7 +858,7 @@ public static void uint2x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_prefix_inc()
         {
             uint2x3 a0 = uint2x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550);
@@ -878,7 +878,7 @@ public static void uint2x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_postfix_inc()
         {
             uint2x3 a0 = uint2x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229);
@@ -898,7 +898,7 @@ public static void uint2x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_prefix_dec()
         {
             uint2x3 a0 = uint2x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159);
@@ -918,7 +918,7 @@ public static void uint2x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_postfix_dec()
         {
             uint2x3 a0 = uint2x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869);
@@ -938,7 +938,7 @@ public static void uint2x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_bitwise_and_wide_wide()
         {
             uint2x3 a0 = uint2x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515);
@@ -962,7 +962,7 @@ public static void uint2x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_bitwise_and_wide_scalar()
         {
             uint2x3 a0 = uint2x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838);
@@ -986,7 +986,7 @@ public static void uint2x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1010,7 +1010,7 @@ public static void uint2x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_bitwise_or_wide_wide()
         {
             uint2x3 a0 = uint2x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930);
@@ -1034,7 +1034,7 @@ public static void uint2x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_bitwise_or_wide_scalar()
         {
             uint2x3 a0 = uint2x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467);
@@ -1058,7 +1058,7 @@ public static void uint2x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1082,7 +1082,7 @@ public static void uint2x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_bitwise_xor_wide_wide()
         {
             uint2x3 a0 = uint2x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850);
@@ -1106,7 +1106,7 @@ public static void uint2x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_bitwise_xor_wide_scalar()
         {
             uint2x3 a0 = uint2x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661);
@@ -1130,7 +1130,7 @@ public static void uint2x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1154,7 +1154,7 @@ public static void uint2x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_left_shift()
         {
             uint2x3 a0 = uint2x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593);
@@ -1178,7 +1178,7 @@ public static void uint2x3_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_right_shift()
         {
             uint2x3 a0 = uint2x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842);
@@ -1202,7 +1202,7 @@ public static void uint2x3_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x3_operator_bitwise_not()
         {
             uint2x3 a0 = uint2x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399);
diff --git a/src/Tests/Tests/Shared/TestUint2x4.gen.cs b/src/Tests/Tests/Shared/TestUint2x4.gen.cs
index 645d9554..f9a8f210 100644
--- a/src/Tests/Tests/Shared/TestUint2x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint2x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint2x4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_zero()
         {
             TestUtils.AreEqual(0u, uint2x4.zero.c0.x);
@@ -28,7 +28,7 @@ public static void uint2x4_zero()
             TestUtils.AreEqual(0u, uint2x4.zero.c3.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_equal_wide_wide()
         {
             uint2x4 a0 = uint2x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316);
@@ -52,7 +52,7 @@ public static void uint2x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_equal_wide_scalar()
         {
             uint2x4 a0 = uint2x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849);
@@ -76,7 +76,7 @@ public static void uint2x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -100,7 +100,7 @@ public static void uint2x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_not_equal_wide_wide()
         {
             uint2x4 a0 = uint2x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074);
@@ -124,7 +124,7 @@ public static void uint2x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_not_equal_wide_scalar()
         {
             uint2x4 a0 = uint2x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717);
@@ -148,7 +148,7 @@ public static void uint2x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -172,7 +172,7 @@ public static void uint2x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_less_wide_wide()
         {
             uint2x4 a0 = uint2x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431);
@@ -196,7 +196,7 @@ public static void uint2x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_less_wide_scalar()
         {
             uint2x4 a0 = uint2x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600);
@@ -220,7 +220,7 @@ public static void uint2x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -244,7 +244,7 @@ public static void uint2x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_greater_wide_wide()
         {
             uint2x4 a0 = uint2x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508);
@@ -268,7 +268,7 @@ public static void uint2x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_greater_wide_scalar()
         {
             uint2x4 a0 = uint2x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098);
@@ -292,7 +292,7 @@ public static void uint2x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -316,7 +316,7 @@ public static void uint2x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_less_equal_wide_wide()
         {
             uint2x4 a0 = uint2x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725);
@@ -340,7 +340,7 @@ public static void uint2x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_less_equal_wide_scalar()
         {
             uint2x4 a0 = uint2x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307);
@@ -364,7 +364,7 @@ public static void uint2x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -388,7 +388,7 @@ public static void uint2x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_greater_equal_wide_wide()
         {
             uint2x4 a0 = uint2x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970);
@@ -412,7 +412,7 @@ public static void uint2x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_greater_equal_wide_scalar()
         {
             uint2x4 a0 = uint2x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187);
@@ -436,7 +436,7 @@ public static void uint2x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -460,7 +460,7 @@ public static void uint2x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_add_wide_wide()
         {
             uint2x4 a0 = uint2x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062);
@@ -484,7 +484,7 @@ public static void uint2x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_add_wide_scalar()
         {
             uint2x4 a0 = uint2x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017);
@@ -508,7 +508,7 @@ public static void uint2x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -532,7 +532,7 @@ public static void uint2x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_sub_wide_wide()
         {
             uint2x4 a0 = uint2x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215);
@@ -556,7 +556,7 @@ public static void uint2x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_sub_wide_scalar()
         {
             uint2x4 a0 = uint2x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511);
@@ -580,7 +580,7 @@ public static void uint2x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -604,7 +604,7 @@ public static void uint2x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_mul_wide_wide()
         {
             uint2x4 a0 = uint2x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644);
@@ -628,7 +628,7 @@ public static void uint2x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_mul_wide_scalar()
         {
             uint2x4 a0 = uint2x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514);
@@ -652,7 +652,7 @@ public static void uint2x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -676,7 +676,7 @@ public static void uint2x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_div_wide_wide()
         {
             uint2x4 a0 = uint2x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814);
@@ -700,7 +700,7 @@ public static void uint2x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_div_wide_scalar()
         {
             uint2x4 a0 = uint2x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670);
@@ -724,7 +724,7 @@ public static void uint2x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -748,7 +748,7 @@ public static void uint2x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_mod_wide_wide()
         {
             uint2x4 a0 = uint2x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004);
@@ -772,7 +772,7 @@ public static void uint2x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_mod_wide_scalar()
         {
             uint2x4 a0 = uint2x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916);
@@ -796,7 +796,7 @@ public static void uint2x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -820,7 +820,7 @@ public static void uint2x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_plus()
         {
             uint2x4 a0 = uint2x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785);
@@ -840,7 +840,7 @@ public static void uint2x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_neg()
         {
             uint2x4 a0 = uint2x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961);
@@ -860,7 +860,7 @@ public static void uint2x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_prefix_inc()
         {
             uint2x4 a0 = uint2x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162);
@@ -880,7 +880,7 @@ public static void uint2x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_postfix_inc()
         {
             uint2x4 a0 = uint2x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244);
@@ -900,7 +900,7 @@ public static void uint2x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_prefix_dec()
         {
             uint2x4 a0 = uint2x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664);
@@ -920,7 +920,7 @@ public static void uint2x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_postfix_dec()
         {
             uint2x4 a0 = uint2x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351);
@@ -940,7 +940,7 @@ public static void uint2x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_bitwise_and_wide_wide()
         {
             uint2x4 a0 = uint2x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753);
@@ -964,7 +964,7 @@ public static void uint2x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_bitwise_and_wide_scalar()
         {
             uint2x4 a0 = uint2x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908);
@@ -988,7 +988,7 @@ public static void uint2x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1012,7 +1012,7 @@ public static void uint2x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_bitwise_or_wide_wide()
         {
             uint2x4 a0 = uint2x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323);
@@ -1036,7 +1036,7 @@ public static void uint2x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_bitwise_or_wide_scalar()
         {
             uint2x4 a0 = uint2x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350);
@@ -1060,7 +1060,7 @@ public static void uint2x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1084,7 +1084,7 @@ public static void uint2x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_bitwise_xor_wide_wide()
         {
             uint2x4 a0 = uint2x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658);
@@ -1108,7 +1108,7 @@ public static void uint2x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_bitwise_xor_wide_scalar()
         {
             uint2x4 a0 = uint2x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783);
@@ -1132,7 +1132,7 @@ public static void uint2x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1156,7 +1156,7 @@ public static void uint2x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_left_shift()
         {
             uint2x4 a0 = uint2x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862);
@@ -1180,7 +1180,7 @@ public static void uint2x4_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_right_shift()
         {
             uint2x4 a0 = uint2x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632);
@@ -1204,7 +1204,7 @@ public static void uint2x4_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2x4_operator_bitwise_not()
         {
             uint2x4 a0 = uint2x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135);
diff --git a/src/Tests/Tests/Shared/TestUint3.gen.cs b/src/Tests/Tests/Shared/TestUint3.gen.cs
index 67055e17..6443db9b 100644
--- a/src/Tests/Tests/Shared/TestUint3.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_zero()
         {
             TestUtils.AreEqual(0u, uint3.zero.x);
@@ -23,7 +23,7 @@ public static void uint3_zero()
             TestUtils.AreEqual(0u, uint3.zero.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_constructor()
         {
             uint3 a = new uint3(1, 2, 3);
@@ -32,7 +32,7 @@ public static void uint3_constructor()
             TestUtils.AreEqual(3, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_scalar_constructor()
         {
             uint3 a = new uint3(17u);
@@ -41,7 +41,7 @@ public static void uint3_scalar_constructor()
             TestUtils.AreEqual(17u, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_static_constructor()
         {
             uint3 a = uint3(1, 2, 3);
@@ -50,7 +50,7 @@ public static void uint3_static_constructor()
             TestUtils.AreEqual(3, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_static_scalar_constructor()
         {
             uint3 a = uint3(17u);
@@ -59,7 +59,7 @@ public static void uint3_static_scalar_constructor()
             TestUtils.AreEqual(17u, a.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_equal_wide_wide()
         {
             uint3 a0 = uint3(2105871082, 35218899, 1550755093);
@@ -83,7 +83,7 @@ public static void uint3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_equal_wide_scalar()
         {
             uint3 a0 = uint3(437822262, 2020661134, 541786900);
@@ -107,7 +107,7 @@ public static void uint3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -131,7 +131,7 @@ public static void uint3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_not_equal_wide_wide()
         {
             uint3 a0 = uint3(1977284100, 1293292704, 1547283851);
@@ -155,7 +155,7 @@ public static void uint3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_not_equal_wide_scalar()
         {
             uint3 a0 = uint3(1038269360, 1427812625, 103361237);
@@ -179,7 +179,7 @@ public static void uint3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -203,7 +203,7 @@ public static void uint3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_less_wide_wide()
         {
             uint3 a0 = uint3(1486550609, 1779244308, 1602148045);
@@ -227,7 +227,7 @@ public static void uint3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_less_wide_scalar()
         {
             uint3 a0 = uint3(796797557, 670113454, 933579492);
@@ -251,7 +251,7 @@ public static void uint3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -275,7 +275,7 @@ public static void uint3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_greater_wide_wide()
         {
             uint3 a0 = uint3(2087717754, 1725569452, 1298066182);
@@ -299,7 +299,7 @@ public static void uint3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_greater_wide_scalar()
         {
             uint3 a0 = uint3(1208626274, 239697208, 1979453345);
@@ -323,7 +323,7 @@ public static void uint3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -347,7 +347,7 @@ public static void uint3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_less_equal_wide_wide()
         {
             uint3 a0 = uint3(154092149, 1515170149, 1083970332);
@@ -371,7 +371,7 @@ public static void uint3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_less_equal_wide_scalar()
         {
             uint3 a0 = uint3(1479531977, 1427983411, 415250630);
@@ -395,7 +395,7 @@ public static void uint3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -419,7 +419,7 @@ public static void uint3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_greater_equal_wide_wide()
         {
             uint3 a0 = uint3(8538378, 2131749726, 265427108);
@@ -443,7 +443,7 @@ public static void uint3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_greater_equal_wide_scalar()
         {
             uint3 a0 = uint3(2049236663, 182691143, 634973382);
@@ -467,7 +467,7 @@ public static void uint3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -491,7 +491,7 @@ public static void uint3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_add_wide_wide()
         {
             uint3 a0 = uint3(2135171378, 21433296, 1954723494);
@@ -515,7 +515,7 @@ public static void uint3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_add_wide_scalar()
         {
             uint3 a0 = uint3(665815972, 1783729250, 1591678394);
@@ -539,7 +539,7 @@ public static void uint3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -563,7 +563,7 @@ public static void uint3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_sub_wide_wide()
         {
             uint3 a0 = uint3(1410318491, 1097280168, 1827039044);
@@ -587,7 +587,7 @@ public static void uint3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_sub_wide_scalar()
         {
             uint3 a0 = uint3(1508669340, 1594795463, 266707545);
@@ -611,7 +611,7 @@ public static void uint3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -635,7 +635,7 @@ public static void uint3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_mul_wide_wide()
         {
             uint3 a0 = uint3(61417577, 219585476, 1362520891);
@@ -659,7 +659,7 @@ public static void uint3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_mul_wide_scalar()
         {
             uint3 a0 = uint3(871746615, 492532311, 570557670);
@@ -683,7 +683,7 @@ public static void uint3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -707,7 +707,7 @@ public static void uint3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_div_wide_wide()
         {
             uint3 a0 = uint3(333171510, 858154903, 1181365836);
@@ -731,7 +731,7 @@ public static void uint3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_div_wide_scalar()
         {
             uint3 a0 = uint3(1433072926, 1073958635, 1195142312);
@@ -755,7 +755,7 @@ public static void uint3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -779,7 +779,7 @@ public static void uint3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_mod_wide_wide()
         {
             uint3 a0 = uint3(258342924, 1454754891, 723352342);
@@ -803,7 +803,7 @@ public static void uint3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_mod_wide_scalar()
         {
             uint3 a0 = uint3(560988938, 629524514, 767711194);
@@ -827,7 +827,7 @@ public static void uint3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -851,7 +851,7 @@ public static void uint3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_plus()
         {
             uint3 a0 = uint3(195392567, 222719748, 1002351013);
@@ -871,7 +871,7 @@ public static void uint3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_neg()
         {
             uint3 a0 = uint3(1385088677, 94114564, 1350664872);
@@ -891,7 +891,7 @@ public static void uint3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_prefix_inc()
         {
             uint3 a0 = uint3(780471723, 954741756, 272723451);
@@ -911,7 +911,7 @@ public static void uint3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_postfix_inc()
         {
             uint3 a0 = uint3(241865086, 2145821641, 1596166022);
@@ -931,7 +931,7 @@ public static void uint3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_prefix_dec()
         {
             uint3 a0 = uint3(1331961415, 1612382200, 1401591249);
@@ -951,7 +951,7 @@ public static void uint3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_postfix_dec()
         {
             uint3 a0 = uint3(1870005937, 1708534798, 704493460);
@@ -971,7 +971,7 @@ public static void uint3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_bitwise_and_wide_wide()
         {
             uint3 a0 = uint3(1055241304, 859321394, 1088358961);
@@ -995,7 +995,7 @@ public static void uint3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_bitwise_and_wide_scalar()
         {
             uint3 a0 = uint3(1513158868, 284695609, 734595037);
@@ -1019,7 +1019,7 @@ public static void uint3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1043,7 +1043,7 @@ public static void uint3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_bitwise_or_wide_wide()
         {
             uint3 a0 = uint3(1920951869, 1750772852, 1420019191);
@@ -1067,7 +1067,7 @@ public static void uint3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_bitwise_or_wide_scalar()
         {
             uint3 a0 = uint3(1295304853, 1307252624, 350194630);
@@ -1091,7 +1091,7 @@ public static void uint3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1115,7 +1115,7 @@ public static void uint3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_bitwise_xor_wide_wide()
         {
             uint3 a0 = uint3(1843655608, 362425681, 640805534);
@@ -1139,7 +1139,7 @@ public static void uint3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_bitwise_xor_wide_scalar()
         {
             uint3 a0 = uint3(169345668, 176087064, 2084362901);
@@ -1163,7 +1163,7 @@ public static void uint3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1187,7 +1187,7 @@ public static void uint3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_left_shift()
         {
             uint3 a0 = uint3(1129100049, 829482269, 1571297368);
@@ -1211,7 +1211,7 @@ public static void uint3_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_right_shift()
         {
             uint3 a0 = uint3(809126085, 908563670, 763568837);
@@ -1235,7 +1235,7 @@ public static void uint3_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_operator_bitwise_not()
         {
             uint3 a0 = uint3(111796841, 603562399, 745091931);
@@ -1255,7 +1255,7 @@ public static void uint3_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_shuffle_result_1()
         {
             uint3 a = uint3(0, 1, 2);
@@ -1269,7 +1269,7 @@ public static void uint3_shuffle_result_1()
             TestUtils.AreEqual((5), shuffle(a, b, ShuffleComponent.RightZ));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_shuffle_result_2()
         {
             uint3 a = uint3(0, 1, 2);
@@ -1293,7 +1293,7 @@ public static void uint3_shuffle_result_2()
             TestUtils.AreEqual(uint2(1, 2), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_shuffle_result_3()
         {
             uint3 a = uint3(0, 1, 2);
@@ -1317,7 +1317,7 @@ public static void uint3_shuffle_result_3()
             TestUtils.AreEqual(uint3(4, 0, 5), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_shuffle_result_4()
         {
             uint3 a = uint3(0, 1, 2);
diff --git a/src/Tests/Tests/Shared/TestUint3x2.gen.cs b/src/Tests/Tests/Shared/TestUint3x2.gen.cs
index 71742df7..0072a061 100644
--- a/src/Tests/Tests/Shared/TestUint3x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint3x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint3x2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_zero()
         {
             TestUtils.AreEqual(0u, uint3x2.zero.c0.x);
@@ -26,7 +26,7 @@ public static void uint3x2_zero()
             TestUtils.AreEqual(0u, uint3x2.zero.c1.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_equal_wide_wide()
         {
             uint3x2 a0 = uint3x2(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098);
@@ -50,7 +50,7 @@ public static void uint3x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_equal_wide_scalar()
         {
             uint3x2 a0 = uint3x2(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405);
@@ -74,7 +74,7 @@ public static void uint3x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -98,7 +98,7 @@ public static void uint3x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_not_equal_wide_wide()
         {
             uint3x2 a0 = uint3x2(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892);
@@ -122,7 +122,7 @@ public static void uint3x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_not_equal_wide_scalar()
         {
             uint3x2 a0 = uint3x2(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802);
@@ -146,7 +146,7 @@ public static void uint3x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -170,7 +170,7 @@ public static void uint3x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_less_wide_wide()
         {
             uint3x2 a0 = uint3x2(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342);
@@ -194,7 +194,7 @@ public static void uint3x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_less_wide_scalar()
         {
             uint3x2 a0 = uint3x2(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673);
@@ -218,7 +218,7 @@ public static void uint3x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -242,7 +242,7 @@ public static void uint3x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_greater_wide_wide()
         {
             uint3x2 a0 = uint3x2(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491);
@@ -266,7 +266,7 @@ public static void uint3x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_greater_wide_scalar()
         {
             uint3x2 a0 = uint3x2(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635);
@@ -290,7 +290,7 @@ public static void uint3x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -314,7 +314,7 @@ public static void uint3x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_less_equal_wide_wide()
         {
             uint3x2 a0 = uint3x2(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627);
@@ -338,7 +338,7 @@ public static void uint3x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_less_equal_wide_scalar()
         {
             uint3x2 a0 = uint3x2(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632);
@@ -362,7 +362,7 @@ public static void uint3x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -386,7 +386,7 @@ public static void uint3x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_greater_equal_wide_wide()
         {
             uint3x2 a0 = uint3x2(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564);
@@ -410,7 +410,7 @@ public static void uint3x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_greater_equal_wide_scalar()
         {
             uint3x2 a0 = uint3x2(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469);
@@ -434,7 +434,7 @@ public static void uint3x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -458,7 +458,7 @@ public static void uint3x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_add_wide_wide()
         {
             uint3x2 a0 = uint3x2(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995);
@@ -482,7 +482,7 @@ public static void uint3x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_add_wide_scalar()
         {
             uint3x2 a0 = uint3x2(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732);
@@ -506,7 +506,7 @@ public static void uint3x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -530,7 +530,7 @@ public static void uint3x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_sub_wide_wide()
         {
             uint3x2 a0 = uint3x2(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868);
@@ -554,7 +554,7 @@ public static void uint3x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_sub_wide_scalar()
         {
             uint3x2 a0 = uint3x2(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328);
@@ -578,7 +578,7 @@ public static void uint3x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -602,7 +602,7 @@ public static void uint3x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_mul_wide_wide()
         {
             uint3x2 a0 = uint3x2(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871);
@@ -626,7 +626,7 @@ public static void uint3x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_mul_wide_scalar()
         {
             uint3x2 a0 = uint3x2(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563);
@@ -650,7 +650,7 @@ public static void uint3x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -674,7 +674,7 @@ public static void uint3x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_div_wide_wide()
         {
             uint3x2 a0 = uint3x2(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420);
@@ -698,7 +698,7 @@ public static void uint3x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_div_wide_scalar()
         {
             uint3x2 a0 = uint3x2(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346);
@@ -722,7 +722,7 @@ public static void uint3x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -746,7 +746,7 @@ public static void uint3x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_mod_wide_wide()
         {
             uint3x2 a0 = uint3x2(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627);
@@ -770,7 +770,7 @@ public static void uint3x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_mod_wide_scalar()
         {
             uint3x2 a0 = uint3x2(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846);
@@ -794,7 +794,7 @@ public static void uint3x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -818,7 +818,7 @@ public static void uint3x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_plus()
         {
             uint3x2 a0 = uint3x2(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277);
@@ -838,7 +838,7 @@ public static void uint3x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_neg()
         {
             uint3x2 a0 = uint3x2(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493);
@@ -858,7 +858,7 @@ public static void uint3x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_prefix_inc()
         {
             uint3x2 a0 = uint3x2(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550);
@@ -878,7 +878,7 @@ public static void uint3x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_postfix_inc()
         {
             uint3x2 a0 = uint3x2(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229);
@@ -898,7 +898,7 @@ public static void uint3x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_prefix_dec()
         {
             uint3x2 a0 = uint3x2(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159);
@@ -918,7 +918,7 @@ public static void uint3x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_postfix_dec()
         {
             uint3x2 a0 = uint3x2(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869);
@@ -938,7 +938,7 @@ public static void uint3x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_bitwise_and_wide_wide()
         {
             uint3x2 a0 = uint3x2(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515);
@@ -962,7 +962,7 @@ public static void uint3x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_bitwise_and_wide_scalar()
         {
             uint3x2 a0 = uint3x2(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838);
@@ -986,7 +986,7 @@ public static void uint3x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1010,7 +1010,7 @@ public static void uint3x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_bitwise_or_wide_wide()
         {
             uint3x2 a0 = uint3x2(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930);
@@ -1034,7 +1034,7 @@ public static void uint3x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_bitwise_or_wide_scalar()
         {
             uint3x2 a0 = uint3x2(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467);
@@ -1058,7 +1058,7 @@ public static void uint3x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1082,7 +1082,7 @@ public static void uint3x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_bitwise_xor_wide_wide()
         {
             uint3x2 a0 = uint3x2(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850);
@@ -1106,7 +1106,7 @@ public static void uint3x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_bitwise_xor_wide_scalar()
         {
             uint3x2 a0 = uint3x2(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661);
@@ -1130,7 +1130,7 @@ public static void uint3x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1154,7 +1154,7 @@ public static void uint3x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_left_shift()
         {
             uint3x2 a0 = uint3x2(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593);
@@ -1178,7 +1178,7 @@ public static void uint3x2_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_right_shift()
         {
             uint3x2 a0 = uint3x2(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842);
@@ -1202,7 +1202,7 @@ public static void uint3x2_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x2_operator_bitwise_not()
         {
             uint3x2 a0 = uint3x2(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399);
diff --git a/src/Tests/Tests/Shared/TestUint3x3.gen.cs b/src/Tests/Tests/Shared/TestUint3x3.gen.cs
index 6e679bba..9e91fc32 100644
--- a/src/Tests/Tests/Shared/TestUint3x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint3x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint3x3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_zero()
         {
             TestUtils.AreEqual(0u, uint3x3.zero.c0.x);
@@ -29,7 +29,7 @@ public static void uint3x3_zero()
             TestUtils.AreEqual(0u, uint3x3.zero.c2.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_identity()
         {
             TestUtils.AreEqual(1u, uint3x3.identity.c0.x);
@@ -43,7 +43,7 @@ public static void uint3x3_identity()
             TestUtils.AreEqual(1u, uint3x3.identity.c2.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_equal_wide_wide()
         {
             uint3x3 a0 = uint3x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367);
@@ -67,7 +67,7 @@ public static void uint3x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_equal_wide_scalar()
         {
             uint3x3 a0 = uint3x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998);
@@ -91,7 +91,7 @@ public static void uint3x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -115,7 +115,7 @@ public static void uint3x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_not_equal_wide_wide()
         {
             uint3x3 a0 = uint3x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678);
@@ -139,7 +139,7 @@ public static void uint3x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_not_equal_wide_scalar()
         {
             uint3x3 a0 = uint3x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423);
@@ -163,7 +163,7 @@ public static void uint3x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -187,7 +187,7 @@ public static void uint3x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_less_wide_wide()
         {
             uint3x3 a0 = uint3x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312);
@@ -211,7 +211,7 @@ public static void uint3x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_less_wide_scalar()
         {
             uint3x3 a0 = uint3x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597);
@@ -235,7 +235,7 @@ public static void uint3x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -259,7 +259,7 @@ public static void uint3x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_greater_wide_wide()
         {
             uint3x3 a0 = uint3x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133);
@@ -283,7 +283,7 @@ public static void uint3x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_greater_wide_scalar()
         {
             uint3x3 a0 = uint3x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855);
@@ -307,7 +307,7 @@ public static void uint3x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -331,7 +331,7 @@ public static void uint3x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_less_equal_wide_wide()
         {
             uint3x3 a0 = uint3x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541);
@@ -355,7 +355,7 @@ public static void uint3x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_less_equal_wide_scalar()
         {
             uint3x3 a0 = uint3x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375);
@@ -379,7 +379,7 @@ public static void uint3x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -403,7 +403,7 @@ public static void uint3x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_greater_equal_wide_wide()
         {
             uint3x3 a0 = uint3x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826);
@@ -427,7 +427,7 @@ public static void uint3x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_greater_equal_wide_scalar()
         {
             uint3x3 a0 = uint3x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669);
@@ -451,7 +451,7 @@ public static void uint3x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -475,7 +475,7 @@ public static void uint3x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_add_wide_wide()
         {
             uint3x3 a0 = uint3x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600);
@@ -499,7 +499,7 @@ public static void uint3x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_add_wide_scalar()
         {
             uint3x3 a0 = uint3x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008);
@@ -523,7 +523,7 @@ public static void uint3x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -547,7 +547,7 @@ public static void uint3x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_sub_wide_wide()
         {
             uint3x3 a0 = uint3x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315);
@@ -571,7 +571,7 @@ public static void uint3x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_sub_wide_scalar()
         {
             uint3x3 a0 = uint3x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113);
@@ -595,7 +595,7 @@ public static void uint3x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -619,7 +619,7 @@ public static void uint3x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_mul_wide_wide()
         {
             uint3x3 a0 = uint3x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583);
@@ -643,7 +643,7 @@ public static void uint3x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_mul_wide_scalar()
         {
             uint3x3 a0 = uint3x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059);
@@ -667,7 +667,7 @@ public static void uint3x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -691,7 +691,7 @@ public static void uint3x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_div_wide_wide()
         {
             uint3x3 a0 = uint3x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195);
@@ -715,7 +715,7 @@ public static void uint3x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_div_wide_scalar()
         {
             uint3x3 a0 = uint3x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136);
@@ -739,7 +739,7 @@ public static void uint3x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -763,7 +763,7 @@ public static void uint3x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_mod_wide_wide()
         {
             uint3x3 a0 = uint3x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101);
@@ -787,7 +787,7 @@ public static void uint3x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_mod_wide_scalar()
         {
             uint3x3 a0 = uint3x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144);
@@ -811,7 +811,7 @@ public static void uint3x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -835,7 +835,7 @@ public static void uint3x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_plus()
         {
             uint3x3 a0 = uint3x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671);
@@ -855,7 +855,7 @@ public static void uint3x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_neg()
         {
             uint3x3 a0 = uint3x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525);
@@ -875,7 +875,7 @@ public static void uint3x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_prefix_inc()
         {
             uint3x3 a0 = uint3x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994);
@@ -895,7 +895,7 @@ public static void uint3x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_postfix_inc()
         {
             uint3x3 a0 = uint3x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247);
@@ -915,7 +915,7 @@ public static void uint3x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_prefix_dec()
         {
             uint3x3 a0 = uint3x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745);
@@ -935,7 +935,7 @@ public static void uint3x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_postfix_dec()
         {
             uint3x3 a0 = uint3x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889);
@@ -955,7 +955,7 @@ public static void uint3x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_bitwise_and_wide_wide()
         {
             uint3x3 a0 = uint3x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656);
@@ -979,7 +979,7 @@ public static void uint3x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_bitwise_and_wide_scalar()
         {
             uint3x3 a0 = uint3x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263);
@@ -1003,7 +1003,7 @@ public static void uint3x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1027,7 +1027,7 @@ public static void uint3x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_bitwise_or_wide_wide()
         {
             uint3x3 a0 = uint3x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869);
@@ -1051,7 +1051,7 @@ public static void uint3x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_bitwise_or_wide_scalar()
         {
             uint3x3 a0 = uint3x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307);
@@ -1075,7 +1075,7 @@ public static void uint3x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1099,7 +1099,7 @@ public static void uint3x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_bitwise_xor_wide_wide()
         {
             uint3x3 a0 = uint3x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251);
@@ -1123,7 +1123,7 @@ public static void uint3x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_bitwise_xor_wide_scalar()
         {
             uint3x3 a0 = uint3x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873);
@@ -1147,7 +1147,7 @@ public static void uint3x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1171,7 +1171,7 @@ public static void uint3x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_left_shift()
         {
             uint3x3 a0 = uint3x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727);
@@ -1195,7 +1195,7 @@ public static void uint3x3_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_right_shift()
         {
             uint3x3 a0 = uint3x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393);
@@ -1219,7 +1219,7 @@ public static void uint3x3_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x3_operator_bitwise_not()
         {
             uint3x3 a0 = uint3x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628);
diff --git a/src/Tests/Tests/Shared/TestUint3x4.gen.cs b/src/Tests/Tests/Shared/TestUint3x4.gen.cs
index 00c414a7..4768c755 100644
--- a/src/Tests/Tests/Shared/TestUint3x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint3x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint3x4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_zero()
         {
             TestUtils.AreEqual(0u, uint3x4.zero.c0.x);
@@ -32,7 +32,7 @@ public static void uint3x4_zero()
             TestUtils.AreEqual(0u, uint3x4.zero.c3.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_equal_wide_wide()
         {
             uint3x4 a0 = uint3x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837);
@@ -56,7 +56,7 @@ public static void uint3x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_equal_wide_scalar()
         {
             uint3x4 a0 = uint3x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137);
@@ -80,7 +80,7 @@ public static void uint3x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -104,7 +104,7 @@ public static void uint3x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_not_equal_wide_wide()
         {
             uint3x4 a0 = uint3x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545);
@@ -128,7 +128,7 @@ public static void uint3x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_not_equal_wide_scalar()
         {
             uint3x4 a0 = uint3x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494);
@@ -152,7 +152,7 @@ public static void uint3x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -176,7 +176,7 @@ public static void uint3x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_less_wide_wide()
         {
             uint3x4 a0 = uint3x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069);
@@ -200,7 +200,7 @@ public static void uint3x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_less_wide_scalar()
         {
             uint3x4 a0 = uint3x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417);
@@ -224,7 +224,7 @@ public static void uint3x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -248,7 +248,7 @@ public static void uint3x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_greater_wide_wide()
         {
             uint3x4 a0 = uint3x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903);
@@ -272,7 +272,7 @@ public static void uint3x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_greater_wide_scalar()
         {
             uint3x4 a0 = uint3x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960);
@@ -296,7 +296,7 @@ public static void uint3x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -320,7 +320,7 @@ public static void uint3x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_less_equal_wide_wide()
         {
             uint3x4 a0 = uint3x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946);
@@ -344,7 +344,7 @@ public static void uint3x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_less_equal_wide_scalar()
         {
             uint3x4 a0 = uint3x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501);
@@ -368,7 +368,7 @@ public static void uint3x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -392,7 +392,7 @@ public static void uint3x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_greater_equal_wide_wide()
         {
             uint3x4 a0 = uint3x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752);
@@ -416,7 +416,7 @@ public static void uint3x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_greater_equal_wide_scalar()
         {
             uint3x4 a0 = uint3x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390);
@@ -440,7 +440,7 @@ public static void uint3x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -464,7 +464,7 @@ public static void uint3x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_add_wide_wide()
         {
             uint3x4 a0 = uint3x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462);
@@ -488,7 +488,7 @@ public static void uint3x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_add_wide_scalar()
         {
             uint3x4 a0 = uint3x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642);
@@ -512,7 +512,7 @@ public static void uint3x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -536,7 +536,7 @@ public static void uint3x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_sub_wide_wide()
         {
             uint3x4 a0 = uint3x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285);
@@ -560,7 +560,7 @@ public static void uint3x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_sub_wide_scalar()
         {
             uint3x4 a0 = uint3x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508);
@@ -584,7 +584,7 @@ public static void uint3x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -608,7 +608,7 @@ public static void uint3x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_mul_wide_wide()
         {
             uint3x4 a0 = uint3x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842);
@@ -632,7 +632,7 @@ public static void uint3x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_mul_wide_scalar()
         {
             uint3x4 a0 = uint3x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203);
@@ -656,7 +656,7 @@ public static void uint3x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -680,7 +680,7 @@ public static void uint3x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_div_wide_wide()
         {
             uint3x4 a0 = uint3x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736);
@@ -704,7 +704,7 @@ public static void uint3x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_div_wide_scalar()
         {
             uint3x4 a0 = uint3x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377);
@@ -728,7 +728,7 @@ public static void uint3x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -752,7 +752,7 @@ public static void uint3x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_mod_wide_wide()
         {
             uint3x4 a0 = uint3x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293);
@@ -776,7 +776,7 @@ public static void uint3x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_mod_wide_scalar()
         {
             uint3x4 a0 = uint3x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785);
@@ -800,7 +800,7 @@ public static void uint3x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -824,7 +824,7 @@ public static void uint3x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_plus()
         {
             uint3x4 a0 = uint3x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223);
@@ -844,7 +844,7 @@ public static void uint3x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_neg()
         {
             uint3x4 a0 = uint3x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822);
@@ -864,7 +864,7 @@ public static void uint3x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_prefix_inc()
         {
             uint3x4 a0 = uint3x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735);
@@ -884,7 +884,7 @@ public static void uint3x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_postfix_inc()
         {
             uint3x4 a0 = uint3x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446);
@@ -904,7 +904,7 @@ public static void uint3x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_prefix_dec()
         {
             uint3x4 a0 = uint3x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220);
@@ -924,7 +924,7 @@ public static void uint3x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_postfix_dec()
         {
             uint3x4 a0 = uint3x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851);
@@ -944,7 +944,7 @@ public static void uint3x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_bitwise_and_wide_wide()
         {
             uint3x4 a0 = uint3x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302);
@@ -968,7 +968,7 @@ public static void uint3x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_bitwise_and_wide_scalar()
         {
             uint3x4 a0 = uint3x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546);
@@ -992,7 +992,7 @@ public static void uint3x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1016,7 +1016,7 @@ public static void uint3x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_bitwise_or_wide_wide()
         {
             uint3x4 a0 = uint3x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227);
@@ -1040,7 +1040,7 @@ public static void uint3x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_bitwise_or_wide_scalar()
         {
             uint3x4 a0 = uint3x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676);
@@ -1064,7 +1064,7 @@ public static void uint3x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1088,7 +1088,7 @@ public static void uint3x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_bitwise_xor_wide_wide()
         {
             uint3x4 a0 = uint3x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919);
@@ -1112,7 +1112,7 @@ public static void uint3x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_bitwise_xor_wide_scalar()
         {
             uint3x4 a0 = uint3x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786);
@@ -1136,7 +1136,7 @@ public static void uint3x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1160,7 +1160,7 @@ public static void uint3x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_left_shift()
         {
             uint3x4 a0 = uint3x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902);
@@ -1184,7 +1184,7 @@ public static void uint3x4_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_right_shift()
         {
             uint3x4 a0 = uint3x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878);
@@ -1208,7 +1208,7 @@ public static void uint3x4_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3x4_operator_bitwise_not()
         {
             uint3x4 a0 = uint3x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785);
diff --git a/src/Tests/Tests/Shared/TestUint4.gen.cs b/src/Tests/Tests/Shared/TestUint4.gen.cs
index 833012cd..8d0b8a6b 100644
--- a/src/Tests/Tests/Shared/TestUint4.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_zero()
         {
             TestUtils.AreEqual(0u, uint4.zero.x);
@@ -24,7 +24,7 @@ public static void uint4_zero()
             TestUtils.AreEqual(0u, uint4.zero.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_constructor()
         {
             uint4 a = new uint4(1, 2, 3, 4);
@@ -34,7 +34,7 @@ public static void uint4_constructor()
             TestUtils.AreEqual(4, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_scalar_constructor()
         {
             uint4 a = new uint4(17u);
@@ -44,7 +44,7 @@ public static void uint4_scalar_constructor()
             TestUtils.AreEqual(17u, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_static_constructor()
         {
             uint4 a = uint4(1, 2, 3, 4);
@@ -54,7 +54,7 @@ public static void uint4_static_constructor()
             TestUtils.AreEqual(4, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_static_scalar_constructor()
         {
             uint4 a = uint4(17u);
@@ -64,7 +64,7 @@ public static void uint4_static_scalar_constructor()
             TestUtils.AreEqual(17u, a.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_equal_wide_wide()
         {
             uint4 a0 = uint4(2105871082, 35218899, 1550755093, 764676020);
@@ -88,7 +88,7 @@ public static void uint4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_equal_wide_scalar()
         {
             uint4 a0 = uint4(437822262, 2020661134, 541786900, 853113810);
@@ -112,7 +112,7 @@ public static void uint4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -136,7 +136,7 @@ public static void uint4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_not_equal_wide_wide()
         {
             uint4 a0 = uint4(1977284100, 1293292704, 1547283851, 422428953);
@@ -160,7 +160,7 @@ public static void uint4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_not_equal_wide_scalar()
         {
             uint4 a0 = uint4(1038269360, 1427812625, 103361237, 1347017023);
@@ -184,7 +184,7 @@ public static void uint4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -208,7 +208,7 @@ public static void uint4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_less_wide_wide()
         {
             uint4 a0 = uint4(1486550609, 1779244308, 1602148045, 1614085440);
@@ -232,7 +232,7 @@ public static void uint4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_less_wide_scalar()
         {
             uint4 a0 = uint4(796797557, 670113454, 933579492, 278884514);
@@ -256,7 +256,7 @@ public static void uint4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -280,7 +280,7 @@ public static void uint4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_greater_wide_wide()
         {
             uint4 a0 = uint4(2087717754, 1725569452, 1298066182, 1693943616);
@@ -304,7 +304,7 @@ public static void uint4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_greater_wide_scalar()
         {
             uint4 a0 = uint4(1208626274, 239697208, 1979453345, 1253474001);
@@ -328,7 +328,7 @@ public static void uint4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -352,7 +352,7 @@ public static void uint4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_less_equal_wide_wide()
         {
             uint4 a0 = uint4(154092149, 1515170149, 1083970332, 785807178);
@@ -376,7 +376,7 @@ public static void uint4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_less_equal_wide_scalar()
         {
             uint4 a0 = uint4(1479531977, 1427983411, 415250630, 1245345407);
@@ -400,7 +400,7 @@ public static void uint4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -424,7 +424,7 @@ public static void uint4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_greater_equal_wide_wide()
         {
             uint4 a0 = uint4(8538378, 2131749726, 265427108, 523609761);
@@ -448,7 +448,7 @@ public static void uint4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_greater_equal_wide_scalar()
         {
             uint4 a0 = uint4(2049236663, 182691143, 634973382, 1197012109);
@@ -472,7 +472,7 @@ public static void uint4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -496,7 +496,7 @@ public static void uint4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_add_wide_wide()
         {
             uint4 a0 = uint4(2135171378, 21433296, 1954723494, 683604307);
@@ -520,7 +520,7 @@ public static void uint4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_add_wide_scalar()
         {
             uint4 a0 = uint4(665815972, 1783729250, 1591678394, 1284528538);
@@ -544,7 +544,7 @@ public static void uint4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -568,7 +568,7 @@ public static void uint4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_sub_wide_wide()
         {
             uint4 a0 = uint4(1410318491, 1097280168, 1827039044, 28881338);
@@ -592,7 +592,7 @@ public static void uint4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_sub_wide_scalar()
         {
             uint4 a0 = uint4(1508669340, 1594795463, 266707545, 643102647);
@@ -616,7 +616,7 @@ public static void uint4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -640,7 +640,7 @@ public static void uint4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_mul_wide_wide()
         {
             uint4 a0 = uint4(61417577, 219585476, 1362520891, 1511084277);
@@ -664,7 +664,7 @@ public static void uint4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_mul_wide_scalar()
         {
             uint4 a0 = uint4(871746615, 492532311, 570557670, 2142306629);
@@ -688,7 +688,7 @@ public static void uint4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -712,7 +712,7 @@ public static void uint4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_div_wide_wide()
         {
             uint4 a0 = uint4(333171510, 858154903, 1181365836, 671357749);
@@ -736,7 +736,7 @@ public static void uint4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_div_wide_scalar()
         {
             uint4 a0 = uint4(1433072926, 1073958635, 1195142312, 536596719);
@@ -760,7 +760,7 @@ public static void uint4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -784,7 +784,7 @@ public static void uint4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_mod_wide_wide()
         {
             uint4 a0 = uint4(258342924, 1454754891, 723352342, 1981431473);
@@ -808,7 +808,7 @@ public static void uint4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_mod_wide_scalar()
         {
             uint4 a0 = uint4(560988938, 629524514, 767711194, 434281967);
@@ -832,7 +832,7 @@ public static void uint4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -856,7 +856,7 @@ public static void uint4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_plus()
         {
             uint4 a0 = uint4(195392567, 222719748, 1002351013, 1570765263);
@@ -876,7 +876,7 @@ public static void uint4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_neg()
         {
             uint4 a0 = uint4(1385088677, 94114564, 1350664872, 1458616659);
@@ -896,7 +896,7 @@ public static void uint4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_prefix_inc()
         {
             uint4 a0 = uint4(780471723, 954741756, 272723451, 2142862245);
@@ -916,7 +916,7 @@ public static void uint4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_postfix_inc()
         {
             uint4 a0 = uint4(241865086, 2145821641, 1596166022, 803592338);
@@ -936,7 +936,7 @@ public static void uint4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_prefix_dec()
         {
             uint4 a0 = uint4(1331961415, 1612382200, 1401591249, 2042075388);
@@ -956,7 +956,7 @@ public static void uint4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_postfix_dec()
         {
             uint4 a0 = uint4(1870005937, 1708534798, 704493460, 462940703);
@@ -976,7 +976,7 @@ public static void uint4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_bitwise_and_wide_wide()
         {
             uint4 a0 = uint4(1055241304, 859321394, 1088358961, 2090949513);
@@ -1000,7 +1000,7 @@ public static void uint4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_bitwise_and_wide_scalar()
         {
             uint4 a0 = uint4(1513158868, 284695609, 734595037, 1566510707);
@@ -1024,7 +1024,7 @@ public static void uint4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1048,7 +1048,7 @@ public static void uint4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_bitwise_or_wide_wide()
         {
             uint4 a0 = uint4(1920951869, 1750772852, 1420019191, 732977093);
@@ -1072,7 +1072,7 @@ public static void uint4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_bitwise_or_wide_scalar()
         {
             uint4 a0 = uint4(1295304853, 1307252624, 350194630, 1128063578);
@@ -1096,7 +1096,7 @@ public static void uint4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1120,7 +1120,7 @@ public static void uint4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_bitwise_xor_wide_wide()
         {
             uint4 a0 = uint4(1843655608, 362425681, 640805534, 1342040268);
@@ -1144,7 +1144,7 @@ public static void uint4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_bitwise_xor_wide_scalar()
         {
             uint4 a0 = uint4(169345668, 176087064, 2084362901, 1663924004);
@@ -1168,7 +1168,7 @@ public static void uint4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1192,7 +1192,7 @@ public static void uint4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_left_shift()
         {
             uint4 a0 = uint4(1129100049, 829482269, 1571297368, 443753193);
@@ -1216,7 +1216,7 @@ public static void uint4_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_right_shift()
         {
             uint4 a0 = uint4(809126085, 908563670, 763568837, 1986717290);
@@ -1240,7 +1240,7 @@ public static void uint4_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_operator_bitwise_not()
         {
             uint4 a0 = uint4(111796841, 603562399, 745091931, 853183268);
@@ -1260,7 +1260,7 @@ public static void uint4_operator_bitwise_not()
             TestUtils.AreEqual(r3, ~a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_shuffle_result_1()
         {
             uint4 a = uint4(0, 1, 2, 3);
@@ -1276,7 +1276,7 @@ public static void uint4_shuffle_result_1()
             TestUtils.AreEqual((7), shuffle(a, b, ShuffleComponent.RightW));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_shuffle_result_2()
         {
             uint4 a = uint4(0, 1, 2, 3);
@@ -1300,7 +1300,7 @@ public static void uint4_shuffle_result_2()
             TestUtils.AreEqual(uint2(1, 3), shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftW));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_shuffle_result_3()
         {
             uint4 a = uint4(0, 1, 2, 3);
@@ -1324,7 +1324,7 @@ public static void uint4_shuffle_result_3()
             TestUtils.AreEqual(uint3(5, 1, 7), shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightW));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_shuffle_result_4()
         {
             uint4 a = uint4(0, 1, 2, 3);
diff --git a/src/Tests/Tests/Shared/TestUint4x2.gen.cs b/src/Tests/Tests/Shared/TestUint4x2.gen.cs
index 9d2bba1f..7f42bc6a 100644
--- a/src/Tests/Tests/Shared/TestUint4x2.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint4x2.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint4x2
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_zero()
         {
             TestUtils.AreEqual(0u, uint4x2.zero.c0.x);
@@ -28,7 +28,7 @@ public static void uint4x2_zero()
             TestUtils.AreEqual(0u, uint4x2.zero.c1.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_equal_wide_wide()
         {
             uint4x2 a0 = uint4x2(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316);
@@ -52,7 +52,7 @@ public static void uint4x2_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_equal_wide_scalar()
         {
             uint4x2 a0 = uint4x2(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849);
@@ -76,7 +76,7 @@ public static void uint4x2_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -100,7 +100,7 @@ public static void uint4x2_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_not_equal_wide_wide()
         {
             uint4x2 a0 = uint4x2(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074);
@@ -124,7 +124,7 @@ public static void uint4x2_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_not_equal_wide_scalar()
         {
             uint4x2 a0 = uint4x2(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717);
@@ -148,7 +148,7 @@ public static void uint4x2_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -172,7 +172,7 @@ public static void uint4x2_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_less_wide_wide()
         {
             uint4x2 a0 = uint4x2(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431);
@@ -196,7 +196,7 @@ public static void uint4x2_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_less_wide_scalar()
         {
             uint4x2 a0 = uint4x2(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600);
@@ -220,7 +220,7 @@ public static void uint4x2_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -244,7 +244,7 @@ public static void uint4x2_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_greater_wide_wide()
         {
             uint4x2 a0 = uint4x2(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508);
@@ -268,7 +268,7 @@ public static void uint4x2_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_greater_wide_scalar()
         {
             uint4x2 a0 = uint4x2(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098);
@@ -292,7 +292,7 @@ public static void uint4x2_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -316,7 +316,7 @@ public static void uint4x2_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_less_equal_wide_wide()
         {
             uint4x2 a0 = uint4x2(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725);
@@ -340,7 +340,7 @@ public static void uint4x2_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_less_equal_wide_scalar()
         {
             uint4x2 a0 = uint4x2(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307);
@@ -364,7 +364,7 @@ public static void uint4x2_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -388,7 +388,7 @@ public static void uint4x2_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_greater_equal_wide_wide()
         {
             uint4x2 a0 = uint4x2(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970);
@@ -412,7 +412,7 @@ public static void uint4x2_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_greater_equal_wide_scalar()
         {
             uint4x2 a0 = uint4x2(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187);
@@ -436,7 +436,7 @@ public static void uint4x2_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -460,7 +460,7 @@ public static void uint4x2_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_add_wide_wide()
         {
             uint4x2 a0 = uint4x2(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062);
@@ -484,7 +484,7 @@ public static void uint4x2_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_add_wide_scalar()
         {
             uint4x2 a0 = uint4x2(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017);
@@ -508,7 +508,7 @@ public static void uint4x2_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -532,7 +532,7 @@ public static void uint4x2_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_sub_wide_wide()
         {
             uint4x2 a0 = uint4x2(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215);
@@ -556,7 +556,7 @@ public static void uint4x2_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_sub_wide_scalar()
         {
             uint4x2 a0 = uint4x2(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511);
@@ -580,7 +580,7 @@ public static void uint4x2_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -604,7 +604,7 @@ public static void uint4x2_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_mul_wide_wide()
         {
             uint4x2 a0 = uint4x2(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644);
@@ -628,7 +628,7 @@ public static void uint4x2_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_mul_wide_scalar()
         {
             uint4x2 a0 = uint4x2(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514);
@@ -652,7 +652,7 @@ public static void uint4x2_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -676,7 +676,7 @@ public static void uint4x2_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_div_wide_wide()
         {
             uint4x2 a0 = uint4x2(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814);
@@ -700,7 +700,7 @@ public static void uint4x2_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_div_wide_scalar()
         {
             uint4x2 a0 = uint4x2(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670);
@@ -724,7 +724,7 @@ public static void uint4x2_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -748,7 +748,7 @@ public static void uint4x2_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_mod_wide_wide()
         {
             uint4x2 a0 = uint4x2(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004);
@@ -772,7 +772,7 @@ public static void uint4x2_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_mod_wide_scalar()
         {
             uint4x2 a0 = uint4x2(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916);
@@ -796,7 +796,7 @@ public static void uint4x2_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -820,7 +820,7 @@ public static void uint4x2_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_plus()
         {
             uint4x2 a0 = uint4x2(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785);
@@ -840,7 +840,7 @@ public static void uint4x2_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_neg()
         {
             uint4x2 a0 = uint4x2(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961);
@@ -860,7 +860,7 @@ public static void uint4x2_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_prefix_inc()
         {
             uint4x2 a0 = uint4x2(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162);
@@ -880,7 +880,7 @@ public static void uint4x2_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_postfix_inc()
         {
             uint4x2 a0 = uint4x2(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244);
@@ -900,7 +900,7 @@ public static void uint4x2_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_prefix_dec()
         {
             uint4x2 a0 = uint4x2(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664);
@@ -920,7 +920,7 @@ public static void uint4x2_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_postfix_dec()
         {
             uint4x2 a0 = uint4x2(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351);
@@ -940,7 +940,7 @@ public static void uint4x2_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_bitwise_and_wide_wide()
         {
             uint4x2 a0 = uint4x2(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753);
@@ -964,7 +964,7 @@ public static void uint4x2_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_bitwise_and_wide_scalar()
         {
             uint4x2 a0 = uint4x2(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908);
@@ -988,7 +988,7 @@ public static void uint4x2_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1012,7 +1012,7 @@ public static void uint4x2_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_bitwise_or_wide_wide()
         {
             uint4x2 a0 = uint4x2(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323);
@@ -1036,7 +1036,7 @@ public static void uint4x2_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_bitwise_or_wide_scalar()
         {
             uint4x2 a0 = uint4x2(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350);
@@ -1060,7 +1060,7 @@ public static void uint4x2_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1084,7 +1084,7 @@ public static void uint4x2_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_bitwise_xor_wide_wide()
         {
             uint4x2 a0 = uint4x2(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658);
@@ -1108,7 +1108,7 @@ public static void uint4x2_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_bitwise_xor_wide_scalar()
         {
             uint4x2 a0 = uint4x2(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783);
@@ -1132,7 +1132,7 @@ public static void uint4x2_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1156,7 +1156,7 @@ public static void uint4x2_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_left_shift()
         {
             uint4x2 a0 = uint4x2(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862);
@@ -1180,7 +1180,7 @@ public static void uint4x2_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_right_shift()
         {
             uint4x2 a0 = uint4x2(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632);
@@ -1204,7 +1204,7 @@ public static void uint4x2_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x2_operator_bitwise_not()
         {
             uint4x2 a0 = uint4x2(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135);
diff --git a/src/Tests/Tests/Shared/TestUint4x3.gen.cs b/src/Tests/Tests/Shared/TestUint4x3.gen.cs
index bc2aba8a..f750426b 100644
--- a/src/Tests/Tests/Shared/TestUint4x3.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint4x3.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint4x3
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_zero()
         {
             TestUtils.AreEqual(0u, uint4x3.zero.c0.x);
@@ -32,7 +32,7 @@ public static void uint4x3_zero()
             TestUtils.AreEqual(0u, uint4x3.zero.c2.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_equal_wide_wide()
         {
             uint4x3 a0 = uint4x3(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837);
@@ -56,7 +56,7 @@ public static void uint4x3_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_equal_wide_scalar()
         {
             uint4x3 a0 = uint4x3(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137);
@@ -80,7 +80,7 @@ public static void uint4x3_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -104,7 +104,7 @@ public static void uint4x3_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_not_equal_wide_wide()
         {
             uint4x3 a0 = uint4x3(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545);
@@ -128,7 +128,7 @@ public static void uint4x3_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_not_equal_wide_scalar()
         {
             uint4x3 a0 = uint4x3(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494);
@@ -152,7 +152,7 @@ public static void uint4x3_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -176,7 +176,7 @@ public static void uint4x3_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_less_wide_wide()
         {
             uint4x3 a0 = uint4x3(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069);
@@ -200,7 +200,7 @@ public static void uint4x3_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_less_wide_scalar()
         {
             uint4x3 a0 = uint4x3(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417);
@@ -224,7 +224,7 @@ public static void uint4x3_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -248,7 +248,7 @@ public static void uint4x3_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_greater_wide_wide()
         {
             uint4x3 a0 = uint4x3(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903);
@@ -272,7 +272,7 @@ public static void uint4x3_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_greater_wide_scalar()
         {
             uint4x3 a0 = uint4x3(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960);
@@ -296,7 +296,7 @@ public static void uint4x3_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -320,7 +320,7 @@ public static void uint4x3_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_less_equal_wide_wide()
         {
             uint4x3 a0 = uint4x3(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946);
@@ -344,7 +344,7 @@ public static void uint4x3_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_less_equal_wide_scalar()
         {
             uint4x3 a0 = uint4x3(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501);
@@ -368,7 +368,7 @@ public static void uint4x3_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -392,7 +392,7 @@ public static void uint4x3_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_greater_equal_wide_wide()
         {
             uint4x3 a0 = uint4x3(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752);
@@ -416,7 +416,7 @@ public static void uint4x3_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_greater_equal_wide_scalar()
         {
             uint4x3 a0 = uint4x3(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390);
@@ -440,7 +440,7 @@ public static void uint4x3_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -464,7 +464,7 @@ public static void uint4x3_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_add_wide_wide()
         {
             uint4x3 a0 = uint4x3(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462);
@@ -488,7 +488,7 @@ public static void uint4x3_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_add_wide_scalar()
         {
             uint4x3 a0 = uint4x3(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642);
@@ -512,7 +512,7 @@ public static void uint4x3_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -536,7 +536,7 @@ public static void uint4x3_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_sub_wide_wide()
         {
             uint4x3 a0 = uint4x3(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285);
@@ -560,7 +560,7 @@ public static void uint4x3_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_sub_wide_scalar()
         {
             uint4x3 a0 = uint4x3(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508);
@@ -584,7 +584,7 @@ public static void uint4x3_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -608,7 +608,7 @@ public static void uint4x3_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_mul_wide_wide()
         {
             uint4x3 a0 = uint4x3(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842);
@@ -632,7 +632,7 @@ public static void uint4x3_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_mul_wide_scalar()
         {
             uint4x3 a0 = uint4x3(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203);
@@ -656,7 +656,7 @@ public static void uint4x3_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -680,7 +680,7 @@ public static void uint4x3_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_div_wide_wide()
         {
             uint4x3 a0 = uint4x3(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736);
@@ -704,7 +704,7 @@ public static void uint4x3_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_div_wide_scalar()
         {
             uint4x3 a0 = uint4x3(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377);
@@ -728,7 +728,7 @@ public static void uint4x3_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -752,7 +752,7 @@ public static void uint4x3_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_mod_wide_wide()
         {
             uint4x3 a0 = uint4x3(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293);
@@ -776,7 +776,7 @@ public static void uint4x3_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_mod_wide_scalar()
         {
             uint4x3 a0 = uint4x3(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785);
@@ -800,7 +800,7 @@ public static void uint4x3_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -824,7 +824,7 @@ public static void uint4x3_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_plus()
         {
             uint4x3 a0 = uint4x3(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223);
@@ -844,7 +844,7 @@ public static void uint4x3_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_neg()
         {
             uint4x3 a0 = uint4x3(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822);
@@ -864,7 +864,7 @@ public static void uint4x3_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_prefix_inc()
         {
             uint4x3 a0 = uint4x3(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735);
@@ -884,7 +884,7 @@ public static void uint4x3_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_postfix_inc()
         {
             uint4x3 a0 = uint4x3(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446);
@@ -904,7 +904,7 @@ public static void uint4x3_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_prefix_dec()
         {
             uint4x3 a0 = uint4x3(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220);
@@ -924,7 +924,7 @@ public static void uint4x3_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_postfix_dec()
         {
             uint4x3 a0 = uint4x3(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851);
@@ -944,7 +944,7 @@ public static void uint4x3_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_bitwise_and_wide_wide()
         {
             uint4x3 a0 = uint4x3(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302);
@@ -968,7 +968,7 @@ public static void uint4x3_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_bitwise_and_wide_scalar()
         {
             uint4x3 a0 = uint4x3(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546);
@@ -992,7 +992,7 @@ public static void uint4x3_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1016,7 +1016,7 @@ public static void uint4x3_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_bitwise_or_wide_wide()
         {
             uint4x3 a0 = uint4x3(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227);
@@ -1040,7 +1040,7 @@ public static void uint4x3_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_bitwise_or_wide_scalar()
         {
             uint4x3 a0 = uint4x3(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676);
@@ -1064,7 +1064,7 @@ public static void uint4x3_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1088,7 +1088,7 @@ public static void uint4x3_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_bitwise_xor_wide_wide()
         {
             uint4x3 a0 = uint4x3(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919);
@@ -1112,7 +1112,7 @@ public static void uint4x3_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_bitwise_xor_wide_scalar()
         {
             uint4x3 a0 = uint4x3(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786);
@@ -1136,7 +1136,7 @@ public static void uint4x3_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1160,7 +1160,7 @@ public static void uint4x3_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_left_shift()
         {
             uint4x3 a0 = uint4x3(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902);
@@ -1184,7 +1184,7 @@ public static void uint4x3_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_right_shift()
         {
             uint4x3 a0 = uint4x3(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878);
@@ -1208,7 +1208,7 @@ public static void uint4x3_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x3_operator_bitwise_not()
         {
             uint4x3 a0 = uint4x3(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785);
diff --git a/src/Tests/Tests/Shared/TestUint4x4.gen.cs b/src/Tests/Tests/Shared/TestUint4x4.gen.cs
index 03234c47..b9fc3f5e 100644
--- a/src/Tests/Tests/Shared/TestUint4x4.gen.cs
+++ b/src/Tests/Tests/Shared/TestUint4x4.gen.cs
@@ -15,7 +15,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public class TestUint4x4
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_zero()
         {
             TestUtils.AreEqual(0u, uint4x4.zero.c0.x);
@@ -36,7 +36,7 @@ public static void uint4x4_zero()
             TestUtils.AreEqual(0u, uint4x4.zero.c3.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_identity()
         {
             TestUtils.AreEqual(1u, uint4x4.identity.c0.x);
@@ -57,7 +57,7 @@ public static void uint4x4_identity()
             TestUtils.AreEqual(1u, uint4x4.identity.c3.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_equal_wide_wide()
         {
             uint4x4 a0 = uint4x4(2105871082, 35218899, 1550755093, 764676020, 606743782, 1208156098, 1023640014, 1038468316, 1416064367, 727143393, 2061243891, 184669837, 1303661760, 2044073738, 370395888, 1822916805);
@@ -81,7 +81,7 @@ public static void uint4x4_operator_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_equal_wide_scalar()
         {
             uint4x4 a0 = uint4x4(437822262, 2020661134, 541786900, 853113810, 23716499, 179951405, 1409026299, 948838849, 953202998, 691955848, 1926262965, 1851546137, 712957637, 2028784869, 1049962241, 1836975611);
@@ -105,7 +105,7 @@ public static void uint4x4_operator_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_equal_scalar_wide()
         {
             uint a0 = (542329200);
@@ -129,7 +129,7 @@ public static void uint4x4_operator_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 == b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_not_equal_wide_wide()
         {
             uint4x4 a0 = uint4x4(1977284100, 1293292704, 1547283851, 422428953, 195833190, 1711544892, 5606053, 737069074, 647386678, 13079405, 1413841590, 1076166545, 1211445174, 1289303469, 1436402489, 1129570126);
@@ -153,7 +153,7 @@ public static void uint4x4_operator_not_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_not_equal_wide_scalar()
         {
             uint4x4 a0 = uint4x4(1038269360, 1427812625, 103361237, 1347017023, 1523584313, 150442802, 660334527, 719113717, 262959423, 484398043, 506946952, 226568494, 507918242, 1702162286, 923269270, 166187260);
@@ -177,7 +177,7 @@ public static void uint4x4_operator_not_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_not_equal_scalar_wide()
         {
             uint a0 = (1652127596);
@@ -201,7 +201,7 @@ public static void uint4x4_operator_not_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 != b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_less_wide_wide()
         {
             uint4x4 a0 = uint4x4(1486550609, 1779244308, 1602148045, 1614085440, 1975613414, 942838342, 1092279031, 373677431, 1419098312, 337757077, 1081797900, 1336745069, 840685445, 1220554047, 2013681746, 192965012);
@@ -225,7 +225,7 @@ public static void uint4x4_operator_less_wide_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_less_wide_scalar()
         {
             uint4x4 a0 = uint4x4(796797557, 670113454, 933579492, 278884514, 318174822, 1117630673, 741886928, 1990922600, 1030849597, 1546212312, 1718582899, 1648393417, 1857132231, 1909506562, 1294006045, 952084157);
@@ -249,7 +249,7 @@ public static void uint4x4_operator_less_wide_scalar()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_less_scalar_wide()
         {
             uint a0 = (186400299);
@@ -273,7 +273,7 @@ public static void uint4x4_operator_less_scalar_wide()
             TestUtils.AreEqual(r3, a3 < b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_greater_wide_wide()
         {
             uint4x4 a0 = uint4x4(2087717754, 1725569452, 1298066182, 1693943616, 1319019629, 70674491, 1042499725, 1002821508, 1021857133, 1744374599, 821751047, 467646903, 2029731638, 1377214212, 1207816926, 474621063);
@@ -297,7 +297,7 @@ public static void uint4x4_operator_greater_wide_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_greater_wide_scalar()
         {
             uint4x4 a0 = uint4x4(1208626274, 239697208, 1979453345, 1253474001, 1590192876, 1487911635, 1673945595, 1662650098, 222749855, 1433540517, 566635217, 1773305960, 1850273578, 206147145, 325913453, 333381537);
@@ -321,7 +321,7 @@ public static void uint4x4_operator_greater_wide_scalar()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_greater_scalar_wide()
         {
             uint a0 = (480938827);
@@ -345,7 +345,7 @@ public static void uint4x4_operator_greater_scalar_wide()
             TestUtils.AreEqual(r3, a3 > b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_less_equal_wide_wide()
         {
             uint4x4 a0 = uint4x4(154092149, 1515170149, 1083970332, 785807178, 1401094881, 310537627, 868328962, 1990816725, 2035349541, 457043352, 1123282035, 1001842946, 1387761992, 195272789, 659549000, 888761458);
@@ -369,7 +369,7 @@ public static void uint4x4_operator_less_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_less_equal_wide_scalar()
         {
             uint4x4 a0 = uint4x4(1479531977, 1427983411, 415250630, 1245345407, 1112546666, 1072990632, 1579912858, 101048307, 1070894375, 509818792, 1910488590, 85452501, 518127023, 1246249980, 1097326500, 1964410699);
@@ -393,7 +393,7 @@ public static void uint4x4_operator_less_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_less_equal_scalar_wide()
         {
             uint a0 = (1899193992);
@@ -417,7 +417,7 @@ public static void uint4x4_operator_less_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 <= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_greater_equal_wide_wide()
         {
             uint4x4 a0 = uint4x4(8538378, 2131749726, 265427108, 523609761, 994991818, 839709564, 101288202, 1886280970, 2032074826, 631221455, 1456286159, 961342752, 424526026, 788481984, 1662488497, 870326690);
@@ -441,7 +441,7 @@ public static void uint4x4_operator_greater_equal_wide_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_greater_equal_wide_scalar()
         {
             uint4x4 a0 = uint4x4(2049236663, 182691143, 634973382, 1197012109, 439837565, 1367606469, 1108037359, 351147187, 1898505669, 411667685, 1998610091, 4652390, 996159180, 2111455181, 727766399, 96217144);
@@ -465,7 +465,7 @@ public static void uint4x4_operator_greater_equal_wide_scalar()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_greater_equal_scalar_wide()
         {
             uint a0 = (1859811087);
@@ -489,7 +489,7 @@ public static void uint4x4_operator_greater_equal_scalar_wide()
             TestUtils.AreEqual(r3, a3 >= b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_add_wide_wide()
         {
             uint4x4 a0 = uint4x4(2135171378, 21433296, 1954723494, 683604307, 1054212315, 1762680995, 1963655852, 1257853062, 2043493600, 976898058, 1915056423, 121374462, 1218855698, 700538222, 1702057277, 1788251699);
@@ -513,7 +513,7 @@ public static void uint4x4_operator_add_wide_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_add_wide_scalar()
         {
             uint4x4 a0 = uint4x4(665815972, 1783729250, 1591678394, 1284528538, 977850224, 71069732, 1138577680, 1200356017, 565982008, 1246759684, 1088001167, 57252642, 678921480, 625943813, 512157429, 1470648741);
@@ -537,7 +537,7 @@ public static void uint4x4_operator_add_wide_scalar()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_add_scalar_wide()
         {
             uint a0 = (359966320);
@@ -561,7 +561,7 @@ public static void uint4x4_operator_add_scalar_wide()
             TestUtils.AreEqual(r3, a3 + b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_sub_wide_wide()
         {
             uint4x4 a0 = uint4x4(1410318491, 1097280168, 1827039044, 28881338, 328720965, 875487868, 212936325, 231977215, 1740021315, 2011295463, 48079003, 591379285, 1125909359, 1842588095, 848561896, 614448464);
@@ -585,7 +585,7 @@ public static void uint4x4_operator_sub_wide_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_sub_wide_scalar()
         {
             uint4x4 a0 = uint4x4(1508669340, 1594795463, 266707545, 643102647, 287705008, 1475644328, 1113286221, 979450511, 2082174113, 1108005498, 304369206, 999244508, 1806482044, 1994553647, 2101812429, 1482736902);
@@ -609,7 +609,7 @@ public static void uint4x4_operator_sub_wide_scalar()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_sub_scalar_wide()
         {
             uint a0 = (893369501);
@@ -633,7 +633,7 @@ public static void uint4x4_operator_sub_scalar_wide()
             TestUtils.AreEqual(r3, a3 - b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_mul_wide_wide()
         {
             uint4x4 a0 = uint4x4(61417577, 219585476, 1362520891, 1511084277, 1481211272, 58211871, 1459591173, 567624644, 1169935583, 1835691886, 385626539, 85934842, 522856538, 278370196, 289217012, 2083410174);
@@ -657,7 +657,7 @@ public static void uint4x4_operator_mul_wide_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_mul_wide_scalar()
         {
             uint4x4 a0 = uint4x4(871746615, 492532311, 570557670, 2142306629, 1610315153, 1526163563, 118471734, 257439514, 364291059, 1186560810, 1584938026, 1357601203, 638897141, 268562104, 1007838321, 1163240135);
@@ -681,7 +681,7 @@ public static void uint4x4_operator_mul_wide_scalar()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_mul_scalar_wide()
         {
             uint a0 = (1152242766);
@@ -705,7 +705,7 @@ public static void uint4x4_operator_mul_scalar_wide()
             TestUtils.AreEqual(r3, a3 * b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_div_wide_wide()
         {
             uint4x4 a0 = uint4x4(333171510, 858154903, 1181365836, 671357749, 1090606752, 803759420, 788404166, 296807814, 575260195, 166625280, 1493729000, 1831739736, 200852358, 129983172, 500176108, 472051781);
@@ -729,7 +729,7 @@ public static void uint4x4_operator_div_wide_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_div_wide_scalar()
         {
             uint4x4 a0 = uint4x4(1433072926, 1073958635, 1195142312, 536596719, 1274375693, 464756346, 806462546, 906504670, 1380905136, 25493909, 1196815948, 123300377, 643754735, 2084019932, 2047825037, 458304263);
@@ -753,7 +753,7 @@ public static void uint4x4_operator_div_wide_scalar()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_div_scalar_wide()
         {
             uint a0 = (519165704);
@@ -777,7 +777,7 @@ public static void uint4x4_operator_div_scalar_wide()
             TestUtils.AreEqual(r3, a3 / b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_mod_wide_wide()
         {
             uint4x4 a0 = uint4x4(258342924, 1454754891, 723352342, 1981431473, 531756042, 716993627, 1667903349, 1331097004, 1776856101, 17598216, 1474345080, 1681376293, 813624265, 1617478722, 498370451, 780075943);
@@ -801,7 +801,7 @@ public static void uint4x4_operator_mod_wide_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_mod_wide_scalar()
         {
             uint4x4 a0 = uint4x4(560988938, 629524514, 767711194, 434281967, 1399805893, 792916846, 1663690927, 598661916, 1776636144, 1287035793, 1743722161, 475209785, 327476870, 1617696916, 379853074, 477430114);
@@ -825,7 +825,7 @@ public static void uint4x4_operator_mod_wide_scalar()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_mod_scalar_wide()
         {
             uint a0 = (933347930);
@@ -849,7 +849,7 @@ public static void uint4x4_operator_mod_scalar_wide()
             TestUtils.AreEqual(r3, a3 % b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_plus()
         {
             uint4x4 a0 = uint4x4(195392567, 222719748, 1002351013, 1570765263, 109389333, 1515950277, 1689763402, 291471785, 264115671, 1084131995, 195779102, 2131702223, 715660442, 1995564647, 69731564, 1317851903);
@@ -869,7 +869,7 @@ public static void uint4x4_operator_plus()
             TestUtils.AreEqual(r3, +a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_neg()
         {
             uint4x4 a0 = uint4x4(1385088677, 94114564, 1350664872, 1458616659, 2067164853, 218122493, 958484951, 270553961, 446497525, 270503114, 1928771252, 1427605822, 2051940607, 1434247484, 485368391, 908365416);
@@ -889,7 +889,7 @@ public static void uint4x4_operator_neg()
             TestUtils.AreEqual(r3, -a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_prefix_inc()
         {
             uint4x4 a0 = uint4x4(780471723, 954741756, 272723451, 2142862245, 606294309, 1514814550, 250124151, 444189162, 1833356994, 1915989169, 1348278302, 129540735, 1584496757, 1170613526, 986715680, 1701179230);
@@ -909,7 +909,7 @@ public static void uint4x4_operator_prefix_inc()
             TestUtils.AreEqual(r3, ++a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_postfix_inc()
         {
             uint4x4 a0 = uint4x4(241865086, 2145821641, 1596166022, 803592338, 529551271, 1656767229, 903047443, 1213663244, 1425753247, 1384002775, 389844650, 1159795446, 1343289659, 1227160199, 947635082, 137930180);
@@ -929,7 +929,7 @@ public static void uint4x4_operator_postfix_inc()
             TestUtils.AreEqual(r3, a3++);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_prefix_dec()
         {
             uint4x4 a0 = uint4x4(1331961415, 1612382200, 1401591249, 2042075388, 1757136546, 1895858159, 1467742422, 578341664, 1336115745, 2059077641, 1169239112, 1862369220, 312317355, 1027543764, 1595492535, 1426262619);
@@ -949,7 +949,7 @@ public static void uint4x4_operator_prefix_dec()
             TestUtils.AreEqual(r3, --a3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_postfix_dec()
         {
             uint4x4 a0 = uint4x4(1870005937, 1708534798, 704493460, 462940703, 2060593573, 228744869, 940247280, 1818778351, 1015253889, 862428933, 1401191870, 2080259851, 653673271, 140452688, 1928164223, 1760916301);
@@ -969,7 +969,7 @@ public static void uint4x4_operator_postfix_dec()
             TestUtils.AreEqual(r3, a3--);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_bitwise_and_wide_wide()
         {
             uint4x4 a0 = uint4x4(1055241304, 859321394, 1088358961, 2090949513, 300561740, 651904515, 1331035868, 2012752753, 1298126656, 53199569, 1752363533, 1303061302, 1929998247, 1504941434, 470682792, 713577376);
@@ -993,7 +993,7 @@ public static void uint4x4_operator_bitwise_and_wide_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_bitwise_and_wide_scalar()
         {
             uint4x4 a0 = uint4x4(1513158868, 284695609, 734595037, 1566510707, 1601252476, 84213838, 314333543, 430856908, 753481263, 327392481, 1619794917, 2143619546, 1873208293, 126982769, 651482651, 1383096952);
@@ -1017,7 +1017,7 @@ public static void uint4x4_operator_bitwise_and_wide_scalar()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_bitwise_and_scalar_wide()
         {
             uint a0 = (477163326);
@@ -1041,7 +1041,7 @@ public static void uint4x4_operator_bitwise_and_scalar_wide()
             TestUtils.AreEqual(r3, a3 & b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_bitwise_or_wide_wide()
         {
             uint4x4 a0 = uint4x4(1920951869, 1750772852, 1420019191, 732977093, 1169579447, 229437930, 1966721348, 2039812323, 113550869, 1912038362, 1569990624, 1490718227, 1686257697, 2137727522, 1569900650, 856504729);
@@ -1065,7 +1065,7 @@ public static void uint4x4_operator_bitwise_or_wide_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_bitwise_or_wide_scalar()
         {
             uint4x4 a0 = uint4x4(1295304853, 1307252624, 350194630, 1128063578, 1774824542, 2085245467, 1988423804, 999162350, 2110327307, 1050875188, 341855232, 1317039676, 228656898, 41280811, 1536908787, 606786773);
@@ -1089,7 +1089,7 @@ public static void uint4x4_operator_bitwise_or_wide_scalar()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_bitwise_or_scalar_wide()
         {
             uint a0 = (1768627592);
@@ -1113,7 +1113,7 @@ public static void uint4x4_operator_bitwise_or_scalar_wide()
             TestUtils.AreEqual(r3, a3 | b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_bitwise_xor_wide_wide()
         {
             uint4x4 a0 = uint4x4(1843655608, 362425681, 640805534, 1342040268, 945678755, 980321850, 390165019, 1682422658, 303897251, 230477768, 1103646442, 1503102919, 26631152, 1016475570, 1862440929, 379588576);
@@ -1137,7 +1137,7 @@ public static void uint4x4_operator_bitwise_xor_wide_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_bitwise_xor_wide_scalar()
         {
             uint4x4 a0 = uint4x4(169345668, 176087064, 2084362901, 1663924004, 193851255, 517476661, 905336222, 863800783, 365003873, 835837496, 954341348, 1464576786, 625604047, 1700827127, 2003392824, 1481813598);
@@ -1161,7 +1161,7 @@ public static void uint4x4_operator_bitwise_xor_wide_scalar()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_bitwise_xor_scalar_wide()
         {
             uint a0 = (1361775641);
@@ -1185,7 +1185,7 @@ public static void uint4x4_operator_bitwise_xor_scalar_wide()
             TestUtils.AreEqual(r3, a3 ^ b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_left_shift()
         {
             uint4x4 a0 = uint4x4(1129100049, 829482269, 1571297368, 443753193, 1872142968, 249554593, 892627436, 980302862, 62369727, 849916599, 1271350845, 108441902, 1959056531, 1779118882, 1451674188, 2082026915);
@@ -1209,7 +1209,7 @@ public static void uint4x4_operator_left_shift()
             TestUtils.AreEqual(r3, a3 << b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_right_shift()
         {
             uint4x4 a0 = uint4x4(809126085, 908563670, 763568837, 1986717290, 1174507510, 646821842, 1242726074, 390811632, 1521420393, 1923166649, 102096936, 400863878, 667378673, 1611921244, 307750782, 479442287);
@@ -1233,7 +1233,7 @@ public static void uint4x4_operator_right_shift()
             TestUtils.AreEqual(r3, a3 >> b3);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4x4_operator_bitwise_not()
         {
             uint4x4 a0 = uint4x4(111796841, 603562399, 745091931, 853183268, 1110916612, 381888399, 1891338755, 1506860135, 771210628, 787710759, 875964607, 96456785, 916013379, 203444882, 1172294211, 1020232736);
diff --git a/src/Tests/Tests/TestMath2.cs b/src/Tests/Tests/TestMath2.cs
index 7bbac675..02b48ddb 100644
--- a/src/Tests/Tests/TestMath2.cs
+++ b/src/Tests/Tests/TestMath2.cs
@@ -8,7 +8,7 @@ namespace Unity.Mathematics.Tests
     [TestFixture]
     public partial class TestMath
     {
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public unsafe void hash_blob()
         {
             byte[] testData = {
@@ -61,7 +61,7 @@ public unsafe void hash_blob()
             }
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public unsafe void hash_blob_unaligned()
         {
             byte[] testData = {
diff --git a/src/Tests/Tests/TestRandom.cs b/src/Tests/Tests/TestRandom.cs
index 9de2112b..35bc9abd 100644
--- a/src/Tests/Tests/TestRandom.cs
+++ b/src/Tests/Tests/TestRandom.cs
@@ -115,14 +115,14 @@ private static double range_check(double x, double min, double max)
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => rnd.NextBool() ? 0.75 : 0.25), 2);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -130,14 +130,14 @@ public static void bool2_uniform()
             ks_test((() => rnd.NextBool2().y ? 0.75 : 0.25), 2);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool2_independent()
         {
             var rnd = new Random(0x6E624EB7u);
             r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool2().xy)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -146,7 +146,7 @@ public static void bool3_uniform()
             ks_test((() => rnd.NextBool3().z ? 0.75 : 0.25), 2);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool3_independent()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -155,7 +155,7 @@ public static void bool3_independent()
             r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool3().yz)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -165,7 +165,7 @@ public static void bool4_uniform()
             ks_test((() => rnd.NextBool4().w ? 0.75 : 0.25), 2);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void bool4_independent()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -177,21 +177,21 @@ public static void bool4_independent()
             r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool4().zw)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => ((rnd.NextInt() & 255u) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int_uniform_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => (((uint)rnd.NextInt() >> 24) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -199,7 +199,7 @@ public static void int_uniform_max()
             ks_test((() => (range_check(rnd.NextInt(max), 0, max) + 0.5) / max), max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int_uniform_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -207,7 +207,7 @@ public static void int_uniform_max_limit()
             ks_test((() => (range_check(rnd.NextInt(max), 0, max) + 0.5) / max), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -217,7 +217,7 @@ public static void int_uniform_min_max()
             ks_test((() => (range_check(rnd.NextInt(min, max), min, max) + 0.5 - min) / range), range);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int_uniform_min_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -227,7 +227,7 @@ public static void int_uniform_min_max_limit()
             ks_test((() => (range_check(rnd.NextInt(min, max), min, max) + 0.5 - min) / range), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -235,7 +235,7 @@ public static void int2_uniform_low_bits()
             ks_test((() => ((rnd.NextInt2().y & 255u) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_uniform_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -243,7 +243,7 @@ public static void int2_uniform_high_bits()
             ks_test((() => (((uint)rnd.NextInt2().y >> 24) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -252,7 +252,7 @@ public static void int2_uniform_max()
             ks_test((() => (range_check(rnd.NextInt2(max).y, 0, max) + 0.5) / max), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -263,7 +263,7 @@ public static void int2_uniform_min_max()
             ks_test((() => (range_check(rnd.NextInt2(min, max).y, min.y, max.y) + 0.5 - min.y) / range.y), range.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_uniform_min_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -274,21 +274,21 @@ public static void int2_uniform_min_max_limit()
             ks_test((() => (range_check(rnd.NextInt2(min, max).y, min, max) + 0.5 - min) / range), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_independent_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             r_test(() => (rnd.NextInt2().xy & 255));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int2_independent_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             r_test(() => ((uint2)rnd.NextInt2().xy >> 24));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -297,7 +297,7 @@ public static void int3_uniform_low_bits()
             ks_test((() => ((rnd.NextInt3().z & 255u) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_uniform_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -306,7 +306,7 @@ public static void int3_uniform_high_bits()
             ks_test((() => (((uint)rnd.NextInt3().z >> 24) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -316,7 +316,7 @@ public static void int3_uniform_max()
             ks_test((() => ((uint)range_check(rnd.NextInt3(max).z, 0, max.z) + 0.5) / max.z), max.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_uniform_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -326,7 +326,7 @@ public static void int3_uniform_max_limit()
             ks_test((() => ((uint)range_check(rnd.NextInt3(max).z, 0, max) + 0.5) / max), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -338,7 +338,7 @@ public static void int3_uniform_min_max()
             ks_test((() => (range_check(rnd.NextInt3(min, max).z, min.z, max.z) + 0.5 - min.z) / range.z), range.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_uniform_min_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -350,7 +350,7 @@ public static void int3_uniform_min_max_limit()
             ks_test((() => (range_check(rnd.NextInt3(min, max).z, min, max) + 0.5 - min) / range), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_independent_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -359,7 +359,7 @@ public static void int3_independent_low_bits()
             r_test(() => (rnd.NextInt3().yz & 255));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int3_independent_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -368,7 +368,7 @@ public static void int3_independent_high_bits()
             r_test(() => ((uint2)rnd.NextInt3().yz >> 24));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -378,7 +378,7 @@ public static void int4_uniform_low_bits()
             ks_test((() => ((rnd.NextInt4().w & 255u) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_uniform_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -388,7 +388,7 @@ public static void int4_uniform_high_bits()
             ks_test((() => (((uint)rnd.NextInt4().w >> 24) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -399,7 +399,7 @@ public static void int4_uniform_max()
             ks_test((() => (range_check(rnd.NextInt4(max).w, 0, max.w) + 0.5) / max.w), max.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_uniform_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -410,7 +410,7 @@ public static void int4_uniform_max_limit()
             ks_test((() => (range_check(rnd.NextInt4(max).w, 0, max) + 0.5) / max), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -423,7 +423,7 @@ public static void int4_uniform_min_max()
             ks_test((() => (range_check(rnd.NextInt4(min, max).w, min.w, max.w) + 0.5 - min.w) / range.w), range.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_uniform_min_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -436,7 +436,7 @@ public static void int4_uniform_min_max_limit()
             ks_test((() => (range_check(rnd.NextInt4(min, max).w, min, max) + 0.5 - min) / range), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_independent_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -448,7 +448,7 @@ public static void int4_independent_low_bits()
             r_test(() => (rnd.NextUInt4().zw & 255));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void int4_independent_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -461,21 +461,21 @@ public static void int4_independent_high_bits()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => ((rnd.NextUInt() & 255u) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint_uniform_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => ((rnd.NextUInt() >> 24) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -483,7 +483,7 @@ public static void uint_uniform_max()
             ks_test((() => (rnd.NextUInt(max) + 0.5) / max), (int)max);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint_uniform_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -491,7 +491,7 @@ public static void uint_uniform_max_limit()
             ks_test((() => (rnd.NextUInt(max) + 0.5) / max), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -501,7 +501,7 @@ public static void uint_uniform_min_max()
             ks_test((() => (range_check(rnd.NextUInt(min, max), min, max) + 0.5 - min) / range), (int)range);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint_uniform_min_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -509,7 +509,7 @@ public static void uint_uniform_min_max_limit()
             ks_test((() => (range_check(rnd.NextUInt(0, max), 0, max) + 0.5) / max), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -517,7 +517,7 @@ public static void uint2_uniform_low_bits()
             ks_test((() => ((rnd.NextUInt2().y & 255u) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_uniform_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -525,7 +525,7 @@ public static void uint2_uniform_high_bits()
             ks_test((() => ((rnd.NextUInt2().y >> 24) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -534,7 +534,7 @@ public static void uint2_uniform_max()
             ks_test((() => (rnd.NextUInt2(max).y + 0.5) / max.y), (int)max.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_uniform_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -543,7 +543,7 @@ public static void uint2_uniform_max_limit()
             ks_test((() => (rnd.NextUInt2(max).y + 0.5) / max), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -554,7 +554,7 @@ public static void uint2_uniform_min_max()
             ks_test((() => (range_check(rnd.NextUInt2(min, max).y, min.y, max.y) + 0.5 - min.y) / range.y), (int)range.y);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_uniform_min_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -563,21 +563,21 @@ public static void uint2_uniform_min_max_limit()
             ks_test((() => (range_check(rnd.NextUInt2(0, max).y, 0, max) + 0.5) / max), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_independent_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             r_test(() => (rnd.NextUInt2().xy & 255));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint2_independent_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             r_test(() => (rnd.NextUInt2().xy >> 24));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -586,7 +586,7 @@ public static void uint3_uniform_low_bits()
             ks_test((() => ((rnd.NextUInt3().z & 255u) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_uniform_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -595,7 +595,7 @@ public static void uint3_uniform_high_bits()
             ks_test((() => ((rnd.NextUInt3().z >> 24) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -605,7 +605,7 @@ public static void uint3_uniform_max()
             ks_test((() => (rnd.NextUInt3(max).z + 0.5) / max.z), (int)max.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_uniform_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -615,7 +615,7 @@ public static void uint3_uniform_max_limit()
             ks_test((() => (rnd.NextUInt3(max).z + 0.5) / max), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -627,7 +627,7 @@ public static void uint3_uniform_min_max()
             ks_test((() => (range_check(rnd.NextUInt3(min, max).z, min.z, max.z) + 0.5 - min.z) / range.z), (int)range.z);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_uniform_min_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -637,7 +637,7 @@ public static void uint3_uniform_min_max_limit()
             ks_test((() => (range_check(rnd.NextUInt3(0, max).z, 0, max) + 0.5) / max), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_independent_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -646,7 +646,7 @@ public static void uint3_independent_low_bits()
             r_test(() => (rnd.NextUInt3().yz & 255));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint3_independent_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -655,7 +655,7 @@ public static void uint3_independent_high_bits()
             r_test(() => (rnd.NextUInt3().yz >> 24));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -665,7 +665,7 @@ public static void uint4_uniform_low_bits()
             ks_test((() => ((rnd.NextUInt4().w & 255u) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_uniform_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -675,7 +675,7 @@ public static void uint4_uniform_high_bits()
             ks_test((() => ((rnd.NextUInt4().w >> 24) + 0.5) / 256.0), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -686,7 +686,7 @@ public static void uint4_uniform_max()
             ks_test((() => (rnd.NextUInt4(max).w + 0.5) / max.w), (int)max.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_uniform_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -697,7 +697,7 @@ public static void uint4_uniform_max_limit()
             ks_test((() => (rnd.NextUInt4(max).w + 0.5) / max), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -710,7 +710,7 @@ public static void uint4_uniform_min_max()
             ks_test((() => (range_check(rnd.NextUInt4(min, max).w, min.w, max.w) + 0.5 - min.w) / range.w), (int)range.w);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_uniform_min_max_limit()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -721,7 +721,7 @@ public static void uint4_uniform_min_max_limit()
             ks_test((() => (range_check(rnd.NextUInt4(0, max).w, 0, max) + 0.5) / max), 256);
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_independent_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -733,7 +733,7 @@ public static void uint4_independent_low_bits()
             r_test(() => (rnd.NextUInt4().zw & 255));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void uint4_independent_high_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -745,21 +745,21 @@ public static void uint4_independent_high_bits()
             r_test(() => (rnd.NextUInt4().zw >> 24));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => range_check01(rnd.NextFloat())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => frac(rnd.NextFloat() * 65536.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -767,7 +767,7 @@ public static void float_uniform_max()
             ks_test((() => range_check(rnd.NextFloat(max), 0.0f, max) / max));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -777,7 +777,7 @@ public static void float_uniform_min_max()
             ks_test((() => (range_check(rnd.NextFloat(min, max), min, max) -min) / range));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -785,7 +785,7 @@ public static void float2_uniform()
             ks_test((() => range_check01(rnd.NextFloat2().y)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -793,7 +793,7 @@ public static void float2_uniform_low_bits()
             ks_test((() => frac(rnd.NextFloat2().y * 65536.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -802,7 +802,7 @@ public static void float2_uniform_max()
             ks_test((() => range_check(rnd.NextFloat2(max).y, 0.0f, max.y) / max.y));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -813,14 +813,14 @@ public static void float2_uniform_min_max()
             ks_test((() => (range_check(rnd.NextFloat2(min, max).y, min.y, max.y) - min.y) / range.y));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_independent()
         {
             var rnd = new Random(0x6E624EB7u);
             r_test((() => rnd.NextFloat2()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -829,7 +829,7 @@ public static void float3_uniform()
             ks_test((() => range_check01(rnd.NextFloat3().z)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -838,7 +838,7 @@ public static void float3_uniform_low_bits()
             ks_test((() => frac(rnd.NextFloat3().z * 65536.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -848,7 +848,7 @@ public static void float3_uniform_max()
             ks_test((() => range_check(rnd.NextFloat3(max).z, 0.0f, max.z) / max.z));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -860,7 +860,7 @@ public static void float3_uniform_min_max()
             ks_test((() => (range_check(rnd.NextFloat3(min, max).z, min.z, max.z) - min.z) / range.z));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_independent()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -869,7 +869,7 @@ public static void float3_independent()
             r_test((() => rnd.NextFloat3().yz));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -879,7 +879,7 @@ public static void float4_uniform()
             ks_test((() => range_check01(rnd.NextFloat4().w)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -889,7 +889,7 @@ public static void float4_uniform_low_bits()
             ks_test((() => frac(rnd.NextFloat4().w * 65536.0f)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -900,7 +900,7 @@ public static void float4_uniform_max()
             ks_test((() => range_check(rnd.NextFloat4(max).w, 0.0f, max.w) / max.w));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -913,7 +913,7 @@ public static void float4_uniform_min_max()
             ks_test((() => (range_check(rnd.NextFloat4(min, max).w, min.w, max.w) - min.w) / range.w));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float4_independent()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -925,21 +925,21 @@ public static void float4_independent()
             r_test((() => rnd.NextFloat4().zw));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => range_check01(rnd.NextDouble())));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
             ks_test((() => frac(rnd.NextDouble() * 35184372088832.0)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -947,7 +947,7 @@ public static void double_uniform_max()
             ks_test((() => range_check(rnd.NextDouble(max), 0.0, max) / max));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -957,7 +957,7 @@ public static void double_uniform_min_max()
             ks_test((() => (range_check(rnd.NextDouble(min, max), min, max) - min) / range));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -965,7 +965,7 @@ public static void double2_uniform()
             ks_test((() => range_check01(rnd.NextDouble2().y)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -973,7 +973,7 @@ public static void double2_uniform_low_bits()
             ks_test((() => frac(rnd.NextDouble2().y * 35184372088832.0)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -982,7 +982,7 @@ public static void double2_uniform_max()
             ks_test((() => range_check(rnd.NextDouble2(max).y, 0.0, max.y) / max.y));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -993,14 +993,14 @@ public static void double2_uniform_min_max()
             ks_test((() => (range_check(rnd.NextDouble2(min, max).y, min.y, max.y) - min.y) / range.y));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_independent()
         {
             var rnd = new Random(0x6E624EB7u);
             r_test((() => rnd.NextDouble2()));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1009,7 +1009,7 @@ public static void double3_uniform()
             ks_test((() => range_check01(rnd.NextDouble3().z)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1018,7 +1018,7 @@ public static void double3_uniform_low_bits()
             ks_test((() => frac(rnd.NextDouble3().z * 35184372088832.0)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1028,7 +1028,7 @@ public static void double3_uniform_max()
             ks_test((() => range_check(rnd.NextDouble3(max).z, 0.0, max.z) / max.z));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1041,7 +1041,7 @@ public static void double3_uniform_min_max()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_independent()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1050,7 +1050,7 @@ public static void double3_independent()
             r_test((() => rnd.NextDouble3().yz));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_uniform()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1060,7 +1060,7 @@ public static void double4_uniform()
             ks_test((() => range_check01(rnd.NextDouble4().w)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_uniform_low_bits()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1070,7 +1070,7 @@ public static void double4_uniform_low_bits()
             ks_test((() => frac(rnd.NextDouble4().w * 35184372088832.0)));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_uniform_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1081,7 +1081,7 @@ public static void double4_uniform_max()
             ks_test((() => range_check(rnd.NextDouble4(max).w, 0.0, max.w) / max.w));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_uniform_min_max()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1094,7 +1094,7 @@ public static void double4_uniform_min_max()
             ks_test((() => (range_check(rnd.NextDouble4(min, max).w, min.w, max.w) - min.w) / range.w));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double4_independent()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1106,7 +1106,7 @@ public static void double4_independent()
             r_test((() => rnd.NextDouble4().zw));
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float2_direction()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1117,7 +1117,7 @@ public static void float2_direction()
             });
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double2_direction()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1129,7 +1129,7 @@ public static void double2_direction()
         }
 
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void float3_direction()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1145,7 +1145,7 @@ public static void float3_direction()
             });
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void double3_direction()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1161,7 +1161,7 @@ public static void double3_direction()
             });
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void quaternion_rotation()
         {
             var rnd = new Random(0x6E624EB7u);
@@ -1183,7 +1183,7 @@ public static void quaternion_rotation()
             });
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void consecutive_seeds_r_test()
         {
             // Check that drawing 1 number from many consecutive seeds has no correlation.
@@ -1195,7 +1195,7 @@ public static void consecutive_seeds_r_test()
             }
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void consecutive_seeds_r_test2()
         {
             // Check that drawing 1 number from many consecutive seeds has no correlation.
@@ -1207,7 +1207,7 @@ public static void consecutive_seeds_r_test2()
             }
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void consecutive_seeds_ks_test()
         {
             // Check that drawing 1 number from many consecutive seeds matches our expected distribution.
@@ -1215,7 +1215,7 @@ public static void consecutive_seeds_ks_test()
             ks_test(() => Random.CreateFromIndex(seed++).NextDouble());
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void consecutive_seeds_ks_test2()
         {
             // Check that drawing 1 number from many consecutive seeds matches our expected distribution.
@@ -1223,7 +1223,7 @@ public static void consecutive_seeds_ks_test2()
             ks_test(() => Random.CreateFromIndex(seed++).NextDouble());
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void similar_seeds()
         {
             // Check to see that two consecutive seeds have no correlation when drawing
@@ -1236,7 +1236,7 @@ public static void similar_seeds()
             }
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void similar_seeds2()
         {
             // Check to see that two consecutive seeds have no correlation when drawing
@@ -1249,7 +1249,7 @@ public static void similar_seeds2()
             }
         }
 
-        [TestCompiler /* For Burst testing */, TestCase /* For player builds */]
+        [TestCompiler]
         public static void wang_hash()
         {
             TestUtils.AreEqual(3232319850u, Random.WangHash(0u));
diff --git a/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs b/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs
index 778b2c25..c53afabc 100644
--- a/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs
+++ b/src/Unity.Mathematics.CodeGen~/VectorGenerator.cs
@@ -2075,7 +2075,7 @@ private void BeginTest(StringBuilder str, string name, bool testCompiler = true)
         {
             if (testCompiler)
             {
-                str.Append("\t\t[TestCompiler /* For Burst testing */, TestCase /* For player builds */]\n");
+                str.Append("\t\t[TestCompiler]\n");
             }
             else
             {

From 6a9b25e77840d5ad66c0bb52a7414287fbc341cc Mon Sep 17 00:00:00 2001
From: Scott Williams <scott.williams@unity3d.com>
Date: Wed, 10 Jan 2024 16:13:21 -0800
Subject: [PATCH 79/94] Update bokken images for CI

---
 .yamato/upm-ci.yml | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/.yamato/upm-ci.yml b/.yamato/upm-ci.yml
index 2a554b38..9335ec46 100644
--- a/.yamato/upm-ci.yml
+++ b/.yamato/upm-ci.yml
@@ -1,28 +1,28 @@
 build_platforms:
   - name: windows
     type: Unity::VM
-    image: sdet/burst-devimage:stable
+    image: package-ci/win10:v4
     flavor: b1.large
   - name: linux
-    image: package-ci/ubuntu:stable
+    image: package-ci/ubuntu-22.04:v4
     type: Unity::VM
     flavor: b1.large
   - name: macOS
-    image: burst/burst_mac:stable
+    image: package-ci/macos-13:v4
     type: Unity::VM::osx
     flavor: b1.large
 
 upmci_platforms:
   - name: windows
     type: Unity::VM
-    image: package-ci/win10:stable
+    image: package-ci/win10:v4
     flavor: b1.large
   - name: linux
-    image: package-ci/ubuntu:stable
+    image: package-ci/ubuntu-22.04:v4
     type: Unity::VM
     flavor: b1.large
   - name: macOS
-    image: package-ci/mac:stable
+    image: package-ci/macos-13:v4
     type: Unity::VM::osx
     flavor: b1.large
 
@@ -85,7 +85,7 @@ package_tests_minimal:
 validate_package_minimal:
   name: Validate Package Linux Minimal
   agent:
-    image: package-ci/ubuntu:stable
+    image: package-ci/ubuntu-22.04:v4
     type: Unity::VM
     flavor: b1.large
   commands:
@@ -135,7 +135,7 @@ publish:
   name: Publish
   agent:
     type: Unity::VM
-    image: package-ci/win10:stable
+    image: package-ci/win10:v4
     flavor: b1.large
   variables:
     UPMCI_ENABLE_PACKAGE_SIGNING: 1
@@ -158,7 +158,7 @@ promote:
   name: Promote
   agent:
     type: Unity::VM
-    image: package-ci/win10:stable
+    image: package-ci/win10:v4
     flavor: b1.large
   variables:
     UPMCI_PROMOTION: 1

From 5fe7e8653c7285265eb3dfe5bee551b2a8c46b2e Mon Sep 17 00:00:00 2001
From: Scott Williams <scott.williams@unity3d.com>
Date: Wed, 10 Jan 2024 16:46:19 -0800
Subject: [PATCH 80/94] Update package verification package and re-add
 internals visible to for testing

---
 .../Packages/manifest.json                       | 16 ++++++++--------
 src/Unity.Mathematics/Properties/AssemblyInfo.cs |  5 +++++
 .../Properties/AssemblyInfo.cs.meta              | 11 +----------
 3 files changed, 14 insertions(+), 18 deletions(-)
 create mode 100644 src/Unity.Mathematics/Properties/AssemblyInfo.cs

diff --git a/Unity.Mathematics.TestProject/Packages/manifest.json b/Unity.Mathematics.TestProject/Packages/manifest.json
index e40c4a4b..932cc93d 100644
--- a/Unity.Mathematics.TestProject/Packages/manifest.json
+++ b/Unity.Mathematics.TestProject/Packages/manifest.json
@@ -1,15 +1,15 @@
 {
   "dependencies": {
-    "com.unity.ai.navigation": "1.1.4",
-    "com.unity.burst": "1.8.7",
-    "com.unity.ide.rider": "3.0.24",
-    "com.unity.ide.visualstudio": "2.0.18",
-    "com.unity.ide.vscode": "1.2.5",
+    "com.unity.ai.navigation": "2.0.0",
+    "com.unity.burst": "1.8.11",
+    "com.unity.ide.rider": "3.0.27",
+    "com.unity.ide.visualstudio": "2.0.22",
     "com.unity.mathematics": "file:../../src",
-    "com.unity.package-validation-suite": "0.8.1-preview",
+    "com.unity.package-validation-suite": "0.62.0-preview",
     "com.unity.properties": "2.1.0-exp.3",
-    "com.unity.test-framework": "1.1.33",
-    "com.unity.test-framework.performance": "2.8.0-preview"
+    "com.unity.test-framework": "1.3.9",
+    "com.unity.test-framework.performance": "3.0.3",
+    "com.unity.modules.accessibility": "1.0.0"
   },
   "testables": [
     "com.unity.mathematics"
diff --git a/src/Unity.Mathematics/Properties/AssemblyInfo.cs b/src/Unity.Mathematics/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..582cdee0
--- /dev/null
+++ b/src/Unity.Mathematics/Properties/AssemblyInfo.cs
@@ -0,0 +1,5 @@
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+[assembly: InternalsVisibleTo("Unity.Mathematics.Tests")]
+[assembly: InternalsVisibleTo("Unity.Mathematics.PerformanceTests")]
diff --git a/src/Unity.Mathematics/Properties/AssemblyInfo.cs.meta b/src/Unity.Mathematics/Properties/AssemblyInfo.cs.meta
index 8b36ead0..048f3093 100644
--- a/src/Unity.Mathematics/Properties/AssemblyInfo.cs.meta
+++ b/src/Unity.Mathematics/Properties/AssemblyInfo.cs.meta
@@ -1,11 +1,2 @@
 fileFormatVersion: 2
-guid: 512db12834bb1f645a5c18af6c16e398
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+guid: fb0d7ffc71c40bd49a849e6427f80cb5
\ No newline at end of file

From aa5b4ca36fce0c30c3c2e50d223f55f75b7c9945 Mon Sep 17 00:00:00 2001
From: Jonathan Mankin <jonathan.mankin@unity3d.com>
Date: Thu, 11 Jan 2024 10:34:23 -0800
Subject: [PATCH 81/94] prep for release

---
 src/CHANGELOG.md | 2 +-
 src/package.json | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index f51a25d0..3cb929f3 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## [Unreleased]
+## [1.3.2] - 2024-01-11
 
 ### Fixed
 * Fixed `math.hash` crash when using IL2CPP builds on Arm 32 bit devices.
diff --git a/src/package.json b/src/package.json
index 5e0509b2..f8870fc2 100755
--- a/src/package.json
+++ b/src/package.json
@@ -1,7 +1,7 @@
 {
     "name": "com.unity.mathematics",
     "displayName": "Mathematics",
-    "version": "1.3.1",
+    "version": "1.3.2",
     "unity": "2018.3",
     "description": "Unity's C# SIMD math library providing vector types and math functions with a shader like syntax.",
     "keywords": [

From 47ef6321a25c7ba609d4de0b45b0902f4eb9565d Mon Sep 17 00:00:00 2001
From: Jonathan Mankin <jonathan.mankin@unity3d.com>
Date: Thu, 11 Jan 2024 12:39:00 -0800
Subject: [PATCH 82/94] change minimum unity version

---
 src/package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/package.json b/src/package.json
index f8870fc2..9944d6fe 100755
--- a/src/package.json
+++ b/src/package.json
@@ -2,7 +2,7 @@
     "name": "com.unity.mathematics",
     "displayName": "Mathematics",
     "version": "1.3.2",
-    "unity": "2018.3",
+    "unity": "2021.3",
     "description": "Unity's C# SIMD math library providing vector types and math functions with a shader like syntax.",
     "keywords": [
         "unity"

From b7986ef8e6ce35cab339222b81027785e30a53c0 Mon Sep 17 00:00:00 2001
From: Jonathan Mankin <jonathan.mankin@unity3d.com>
Date: Thu, 11 Jan 2024 12:58:09 -0800
Subject: [PATCH 83/94] Update CHANGELOG.md

---
 src/CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index 3cb929f3..484b5af3 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -5,6 +5,7 @@
 ### Fixed
 * Fixed `math.hash` crash when using IL2CPP builds on Arm 32 bit devices.
 * Fixed obsolete method usage warnings for `MatrixDrawer.CanCacheInspectorGUI` and `PrimitiveVectorDrawer.CanCacheInspectorGUI` in UNITY_2023_2_OR_NEWER.
+* Updated minimum editor version to 2021.3
 
 ## [1.3.1] - 2023-07-12
 

From 1695a8503482a3131be78cc26308a93f82c05b04 Mon Sep 17 00:00:00 2001
From: Jonathan Mankin <jonathan.mankin@unity3d.com>
Date: Thu, 11 Jan 2024 14:31:59 -0800
Subject: [PATCH 84/94] update validation exceptions

Need an exception due to us updating the minimum unity version to a supported Unity Version.
---
 src/ValidationExceptions.json | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/ValidationExceptions.json b/src/ValidationExceptions.json
index e8a81512..3406ed9e 100644
--- a/src/ValidationExceptions.json
+++ b/src/ValidationExceptions.json
@@ -1,5 +1,10 @@
 {
     "ErrorExceptions": [
+        {
+            "ValidationTest": "Package Unity Version Validation",
+            "ExceptionMessage": "The Unity version requirement is more strict than in the previous version of the package. Increment the minor version of the package to leave patch versions available for previous version. Read more about this error and potential solutions at https://docs.unity3d.com/Packages/com.unity.package-validation-suite@latest/index.html?preview=1&subfolder=/manual/package_unity_version_validation_error.html#the-unity-version-requirement-is-more-strict-than-in-the-previous-version-of-the-package",
+            "PackageVersion": "1.3.2"
+        }
     ],
     "WarningExceptions": []
 }
\ No newline at end of file

From 09c5980bd9588718743e64ace3b76f069486765e Mon Sep 17 00:00:00 2001
From: Gregory Labute <gregoryl@unity3d.com>
Date: Fri, 15 Aug 2025 13:36:31 -0400
Subject: [PATCH 85/94] Update PostNormalizedVectorDrawer.cs tooltip display

---
 .../PostNormalizedVectorDrawer.cs                    | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/Unity.Mathematics.Editor/PostNormalizedVectorDrawer.cs b/src/Unity.Mathematics.Editor/PostNormalizedVectorDrawer.cs
index d4189eda..eaa2a07d 100644
--- a/src/Unity.Mathematics.Editor/PostNormalizedVectorDrawer.cs
+++ b/src/Unity.Mathematics.Editor/PostNormalizedVectorDrawer.cs
@@ -12,8 +12,10 @@ class PostNormalizedVectorDrawer : PrimitiveVectorDrawer
     {
         static class Content
         {
-            public static readonly string tooltip =
-                L10n.Tr("Values you enter will be post-normalized. You will see the normalized result if you change selection and view the values again.");
+            public static readonly GUIContent Tooltip = new (
+                string.Empty, 
+                L10n.Tr("Values you enter will be post-normalized. You will see the normalized result if you "
+                    + "change selection and view the values again."));
         }
 
         class VectorPropertyGUIData
@@ -181,8 +183,12 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
                 return;
             }
 
+            // Avoid polluting the passed-in GUIContent - it might be static and shared.
             if (string.IsNullOrEmpty(label.tooltip))
-                label.tooltip = Content.tooltip;
+            {
+                Content.Tooltip.text = label.text;
+                label = Content.Tooltip;
+            }
 
             guiData.RebuildIfDirty();
             guiData.ApplyPreNormalizedValues();

From 4a423cc5dae8532391e57c37ab81dab12a64ea15 Mon Sep 17 00:00:00 2001
From: Gregory Labute <gregoryl@unity3d.com>
Date: Mon, 25 Aug 2025 21:24:50 -0400
Subject: [PATCH 86/94] PrimitiveVectorDrawer doesn't change passed-in
 GUIContent (#251)

* PrimitiveVectorDrawer doesn't change passed-in GUIContent

* Update PrimitiveVectorDrawer.cs

* Fix compile error.

---------

Co-authored-by: Dale Kim <3121968+unpacklo@users.noreply.github.com>
---
 src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs b/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs
index cde01f38..5353bdcb 100644
--- a/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs
+++ b/src/Unity.Mathematics.Editor/PrimitiveVectorDrawer.cs
@@ -36,8 +36,8 @@ static class Content
             public static readonly string doNotNormalizeCompatibility = L10n.Tr(
                 $"{typeof(DoNotNormalizeAttribute).Name} only works with {typeof(quaternion)} and primitive vector types."
             );
-            public static readonly string doNotNormalizeTooltip =
-                L10n.Tr("This value is not normalized, which may produce unexpected results.");
+            public static readonly GUIContent doNotNormalizeContent = new GUIContent("", 
+                L10n.Tr("This value is not normalized, which may produce unexpected results."));
 
             public static readonly GUIContent[] labels2 = { new GUIContent("X"), new GUIContent("Y") };
             public static readonly GUIContent[] labels3 = { new GUIContent("X"), new GUIContent("Y"), new GUIContent("Z") };
@@ -89,8 +89,10 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
             }
 
             if (attribute is DoNotNormalizeAttribute && string.IsNullOrEmpty(label.tooltip))
-                label.tooltip = Content.doNotNormalizeTooltip;
-
+            {
+                Content.doNotNormalizeContent.text = label.text;
+                label = Content.doNotNormalizeContent;
+            }
             label = EditorGUI.BeginProperty(position, label, property);
             var valuesIterator = property.FindPropertyRelative(startIter);
             MultiPropertyField(position, subLabels, valuesIterator, label);

From 00913ffa65b5a596a8c2b0700ae4bd715d3a1e44 Mon Sep 17 00:00:00 2001
From: Peter Lu <68305151+plu-unity@users.noreply.github.com>
Date: Mon, 5 Jan 2026 17:42:31 -0500
Subject: [PATCH 87/94] Update upm-ci.yml to reflect currently supported editor
 versions for the package

---
 .yamato/upm-ci.yml | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/.yamato/upm-ci.yml b/.yamato/upm-ci.yml
index 9335ec46..9b98958e 100644
--- a/.yamato/upm-ci.yml
+++ b/.yamato/upm-ci.yml
@@ -27,24 +27,24 @@ upmci_platforms:
     flavor: b1.large
 
 validate_editor_versions:
-  - version: "2021.3"
-    display_name: "2021.3"
   - version: "2022.3"
     display_name: "2022.3"
-  - version: "2023.1"
-    display_name: "2023.1"
-  - version: "trunk"
-    display_name: "trunk"
+  - version: "6000.0"
+    display_name: "6000.0"
+  - version: "6000.3"
+    display_name: "6000.3"
+  - version: "6000.4"
+    display_name: "6000.4"
 
 package_tests_editor_versions:
-  - version: "2021.3"
-    display_name: "2021.3"
   - version: "2022.3"
     display_name: "2022.3"
-  - version: "2023.1"
-    display_name: "2023.1"
-  - version: "trunk"
-    display_name: "trunk"
+  - version: "6000.0"
+    display_name: "6000.0"
+  - version: "6000.3"
+    display_name: "6000.3"
+  - version: "6000.4"
+    display_name: "6000.4"
 ---
 
 {% for platform in upmci_platforms %}

From 3d6a653c29cfb4d2f54185b3832a985bed887222 Mon Sep 17 00:00:00 2001
From: Peter Lu <68305151+plu-unity@users.noreply.github.com>
Date: Mon, 5 Jan 2026 23:26:13 -0500
Subject: [PATCH 88/94] Update some 2021.3 editor job dependencies in
 upm-ci.yml to 6000.3

---
 .yamato/upm-ci.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.yamato/upm-ci.yml b/.yamato/upm-ci.yml
index 9b98958e..3675e42d 100644
--- a/.yamato/upm-ci.yml
+++ b/.yamato/upm-ci.yml
@@ -79,7 +79,7 @@ package_tests_minimal:
   name: Package tests minimal
   dependencies:
   {% for platform in upmci_platforms %}
-    - .yamato/upm-ci.yml#package_tests_{{platform.name}}_2021.3
+    - .yamato/upm-ci.yml#package_tests_{{platform.name}}_6000.3
   {% endfor %}
 
 validate_package_minimal:
@@ -91,7 +91,7 @@ validate_package_minimal:
   commands:
     - npm install upm-ci-utils@stable --registry https://artifactory.prd.cds.internal.unity3d.com/artifactory/api/npm/upm-npm -g
     - upm-ci package pack --package-path src/
-    - upm-ci package test --package-path src/ --unity-version 2021.3
+    - upm-ci package test --package-path src/ --unity-version 6000.3
   artifacts:
     packages:
       paths:

From 4a4ece972005c927d6804ee6d6e4ff6961bff22d Mon Sep 17 00:00:00 2001
From: Peter Lu <peter.lu@unity3d.com>
Date: Fri, 17 Jul 2026 20:04:29 -0400
Subject: [PATCH 89/94] Added a remark to NextFloatX and NextDoubleX methods
 with a min and max parameter.

The affine (min, max) overloads compute the result as
value * (max - min) + min. Floating-point rounding (round-half-to-even)
can in rare cases return exactly max instead of a value strictly below
it, so the [min, max) interval is the intent rather than a hard
guarantee.
---
 src/Unity.Mathematics/random.cs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/Unity.Mathematics/random.cs b/src/Unity.Mathematics/random.cs
index 3c94b6e3..a6c77d5c 100644
--- a/src/Unity.Mathematics/random.cs
+++ b/src/Unity.Mathematics/random.cs
@@ -468,6 +468,7 @@ public float4 NextFloat4()
         /// <param name="min">The minimum value to generate, inclusive.</param>
         /// <param name="max">The maximum value to generate, exclusive.</param>
         /// <returns>A uniformly random float value in the range [min, max).</returns>
+        /// <remarks>The result is computed as `NextFloat() * (max - min) + min`, so floating-point rounding can in rare cases return a value equal to `max` rather than strictly less than it. Clamp the result if you require a value strictly less than `max`.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public float NextFloat(float min, float max) { return NextFloat() * (max - min) + min; }
 
@@ -475,6 +476,7 @@ public float4 NextFloat4()
         /// <param name="min">The componentwise minimum value to generate, inclusive.</param>
         /// <param name="max">The componentwise maximum value to generate, exclusive.</param>
         /// <returns>A uniformly random float2 value in the range [min, max).</returns>
+        /// <remarks>Each component is computed as `NextFloat() * (max - min) + min`, so floating-point rounding can in rare cases return a component equal to the corresponding component of `max` rather than strictly less than it. Clamp the result if you require components strictly less than `max`.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public float2 NextFloat2(float2 min, float2 max) { return NextFloat2() * (max - min) + min; }
 
@@ -482,6 +484,7 @@ public float4 NextFloat4()
         /// <param name="min">The componentwise minimum value to generate, inclusive.</param>
         /// <param name="max">The componentwise maximum value to generate, exclusive.</param>
         /// <returns>A uniformly random float3 value in the range [min, max).</returns>
+        /// <remarks>Each component is computed as `NextFloat() * (max - min) + min`, so floating-point rounding can in rare cases return a component equal to the corresponding component of `max` rather than strictly less than it. Clamp the result if you require components strictly less than `max`.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public float3 NextFloat3(float3 min, float3 max) { return NextFloat3() * (max - min) + min; }
 
@@ -489,6 +492,7 @@ public float4 NextFloat4()
         /// <param name="min">The componentwise minimum value to generate, inclusive.</param>
         /// <param name="max">The componentwise maximum value to generate, exclusive.</param>
         /// <returns>A uniformly random float4 value in the range [min, max).</returns>
+        /// <remarks>Each component is computed as `NextFloat() * (max - min) + min`, so floating-point rounding can in rare cases return a component equal to the corresponding component of `max` rather than strictly less than it. Clamp the result if you require components strictly less than `max`.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public float4 NextFloat4(float4 min, float4 max) { return NextFloat4() * (max - min) + min; }
 
@@ -572,6 +576,7 @@ public double4 NextDouble4()
         /// <param name="min">The minimum value to generate, inclusive.</param>
         /// <param name="max">The maximum value to generate, exclusive.</param>
         /// <returns>A uniformly random double value in the range [min, max).</returns>
+        /// <remarks>The result is computed as `NextDouble() * (max - min) + min`, so floating-point rounding can in rare cases return a value equal to `max` rather than strictly less than it. Clamp the result if you require a value strictly less than `max`.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public double NextDouble(double min, double max) { return NextDouble() * (max - min) + min; }
 
@@ -579,6 +584,7 @@ public double4 NextDouble4()
         /// <param name="min">The componentwise minimum value to generate, inclusive.</param>
         /// <param name="max">The componentwise maximum value to generate, exclusive.</param>
         /// <returns>A uniformly random double2 value in the range [min, max).</returns>
+        /// <remarks>Each component is computed as `NextDouble() * (max - min) + min`, so floating-point rounding can in rare cases return a component equal to the corresponding component of `max` rather than strictly less than it. Clamp the result if you require components strictly less than `max`.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public double2 NextDouble2(double2 min, double2 max) { return NextDouble2() * (max - min) + min; }
 
@@ -586,6 +592,7 @@ public double4 NextDouble4()
         /// <param name="min">The componentwise minimum value to generate, inclusive.</param>
         /// <param name="max">The componentwise maximum value to generate, exclusive.</param>
         /// <returns>A uniformly random double3 value in the range [min, max).</returns>
+        /// <remarks>Each component is computed as `NextDouble() * (max - min) + min`, so floating-point rounding can in rare cases return a component equal to the corresponding component of `max` rather than strictly less than it. Clamp the result if you require components strictly less than `max`.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public double3 NextDouble3(double3 min, double3 max) { return NextDouble3() * (max - min) + min; }
 
@@ -593,6 +600,7 @@ public double4 NextDouble4()
         /// <param name="min">The componentwise minimum value to generate, inclusive.</param>
         /// <param name="max">The componentwise maximum value to generate, exclusive.</param>
         /// <returns>A uniformly random double4 value in the range [min, max).</returns>
+        /// <remarks>Each component is computed as `NextDouble() * (max - min) + min`, so floating-point rounding can in rare cases return a component equal to the corresponding component of `max` rather than strictly less than it. Clamp the result if you require components strictly less than `max`.</remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public double4 NextDouble4(double4 min, double4 max) { return NextDouble4() * (max - min) + min; }
 

From f37f578a7cc32f599f96cdab007c88d12b6c8605 Mon Sep 17 00:00:00 2001
From: Peter Lu <peter.lu@unity3d.com>
Date: Fri, 17 Jul 2026 20:06:27 -0400
Subject: [PATCH 90/94] -Added a unreleased changelog version and entry for the
 documentation port -Removed the ValidationExceptions.json entry needed for
 the last package release

---
 src/CHANGELOG.md              | 3 +++
 src/ValidationExceptions.json | 8 +-------
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index 484b5af3..595ffd52 100755
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -1,5 +1,8 @@
 # Changelog
 
+## [Unreleased]
+* Added a documentation remark for Random NextFloat and NextDouble methods with a min and max parameter.
+
 ## [1.3.2] - 2024-01-11
 
 ### Fixed
diff --git a/src/ValidationExceptions.json b/src/ValidationExceptions.json
index 3406ed9e..c9391d89 100644
--- a/src/ValidationExceptions.json
+++ b/src/ValidationExceptions.json
@@ -1,10 +1,4 @@
 {
-    "ErrorExceptions": [
-        {
-            "ValidationTest": "Package Unity Version Validation",
-            "ExceptionMessage": "The Unity version requirement is more strict than in the previous version of the package. Increment the minor version of the package to leave patch versions available for previous version. Read more about this error and potential solutions at https://docs.unity3d.com/Packages/com.unity.package-validation-suite@latest/index.html?preview=1&subfolder=/manual/package_unity_version_validation_error.html#the-unity-version-requirement-is-more-strict-than-in-the-previous-version-of-the-package",
-            "PackageVersion": "1.3.2"
-        }
-    ],
+    "ErrorExceptions": [],
     "WarningExceptions": []
 }
\ No newline at end of file

From 6ffc2a46a14f4666ac19048356b57ebe3701ebea Mon Sep 17 00:00:00 2001
From: Peter Lu <peter.lu@unity3d.com>
Date: Fri, 17 Jul 2026 20:09:43 -0400
Subject: [PATCH 91/94] Removing out of support editors from package validation
 YML

---
 .yamato/upm-ci.yml | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/.yamato/upm-ci.yml b/.yamato/upm-ci.yml
index 3675e42d..27b41405 100644
--- a/.yamato/upm-ci.yml
+++ b/.yamato/upm-ci.yml
@@ -27,24 +27,16 @@ upmci_platforms:
     flavor: b1.large
 
 validate_editor_versions:
-  - version: "2022.3"
-    display_name: "2022.3"
   - version: "6000.0"
     display_name: "6000.0"
   - version: "6000.3"
     display_name: "6000.3"
-  - version: "6000.4"
-    display_name: "6000.4"
 
 package_tests_editor_versions:
-  - version: "2022.3"
-    display_name: "2022.3"
   - version: "6000.0"
     display_name: "6000.0"
   - version: "6000.3"
     display_name: "6000.3"
-  - version: "6000.4"
-    display_name: "6000.4"
 ---
 
 {% for platform in upmci_platforms %}

From 5141def0a12e24c58e565224971a52bd47ce62a9 Mon Sep 17 00:00:00 2001
From: Jonathan Mankin <jonathan.mankin@unity3d.com>
Date: Thu, 11 Jan 2024 14:31:59 -0800
Subject: [PATCH 92/94] update validation exceptions

Need an exception due to us updating the minimum unity version to a supported Unity Version.
---
 src/ValidationExceptions.json | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/ValidationExceptions.json b/src/ValidationExceptions.json
index c9391d89..3406ed9e 100644
--- a/src/ValidationExceptions.json
+++ b/src/ValidationExceptions.json
@@ -1,4 +1,10 @@
 {
-    "ErrorExceptions": [],
+    "ErrorExceptions": [
+        {
+            "ValidationTest": "Package Unity Version Validation",
+            "ExceptionMessage": "The Unity version requirement is more strict than in the previous version of the package. Increment the minor version of the package to leave patch versions available for previous version. Read more about this error and potential solutions at https://docs.unity3d.com/Packages/com.unity.package-validation-suite@latest/index.html?preview=1&subfolder=/manual/package_unity_version_validation_error.html#the-unity-version-requirement-is-more-strict-than-in-the-previous-version-of-the-package",
+            "PackageVersion": "1.3.2"
+        }
+    ],
     "WarningExceptions": []
 }
\ No newline at end of file

From 045e4fb3cf48447eda190cba82ac7ad410c1a08c Mon Sep 17 00:00:00 2001
From: "christopher.sexton" <christopher.sexton@unity3d.com>
Date: Wed, 5 Aug 2026 10:20:33 +0200
Subject: [PATCH 93/94] Fix copy-paste error in floor descriptions: round up ->
 down

---
 src/Unity.Mathematics/math.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Unity.Mathematics/math.cs b/src/Unity.Mathematics/math.cs
index a1b4800d..b17d04fe 100644
--- a/src/Unity.Mathematics/math.cs
+++ b/src/Unity.Mathematics/math.cs
@@ -2511,7 +2511,7 @@ public static bool4 ispow2(uint4 x)
         public static double4 asin(double4 x) { return new double4(asin(x.x), asin(x.y), asin(x.z), asin(x.w)); }
 
 
-        /// <summary>Returns the result of rounding a float value up to the nearest integral value less or equal to the original value.</summary>
+        /// <summary>Returns the result of rounding a float value down to the nearest integral value less or equal to the original value.</summary>
         /// <param name="x">Input value.</param>
         /// <returns>The round down to nearest integral value of the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -2536,7 +2536,7 @@ public static bool4 ispow2(uint4 x)
         public static float4 floor(float4 x) { return new float4(floor(x.x), floor(x.y), floor(x.z), floor(x.w)); }
 
 
-        /// <summary>Returns the result of rounding a double value up to the nearest integral value less or equal to the original value.</summary>
+        /// <summary>Returns the result of rounding a double value down to the nearest integral value less or equal to the original value.</summary>
         /// <param name="x">Input value.</param>
         /// <returns>The round down to nearest integral value of the input.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

From 73b0776667829a6b65d53a8e003ee8f2d241f8f4 Mon Sep 17 00:00:00 2001
From: "christopher.sexton" <christopher.sexton@unity3d.com>
Date: Wed, 5 Aug 2026 14:04:35 +0200
Subject: [PATCH 94/94] Add notice on migration of docs from 6.5

---
 src/Documentation~/index.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/Documentation~/index.md b/src/Documentation~/index.md
index f158d0db..0b61abb2 100644
--- a/src/Documentation~/index.md
+++ b/src/Documentation~/index.md
@@ -16,6 +16,9 @@ Plus elementary functions:
 
 You can install the Mathematics package through Unity's Package Manager. For more information, see the Unity User Manual documentation on [Adding and removing packages](https://docs.unity3d.com/Manual/upm-ui-actions.html).
 
+>[!IMPORTANT]
+>From Unity 6.5, Unity Mathematics is a built-in module of the core Editor and Engine and its APIs are available to user code by default in the `Unity.Mathematics` namespace, with no package installation required. Accordingly, from Unity 6.5 the Unity Mathematics API documentation is part of the [core Scripting API reference](https://docs.unity3d.com/ScriptReference/Unity.Mathematics.math.html), and the user manual is integrated with [the core Unity user manual](https://docs.unity3d.com/Manual/unity-mathematics.html).
+
 ### Editor config
 
 Unity Mathematics uses [editorconfig](http://editorconfig.org/) to keep files formatted for EOL and spaces.